# ##### BEGIN GPL LICENSE BLOCK #####
#
#  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

bl_info = {
    'name': 'Import Autocad DXF Format (.dxf)',
    'author': 'Thomas Larsson, Remigiusz Fiedler',
    'version': (0, 1, 5),
    "blender": (2, 5, 7),
    "api": 36079,
    'location': 'File > Import > Autocad (.dxf)',
    'description': 'Import files in the Autocad DXF format (.dxf)',
    'warning': 'only a part of DXF specification is supported: Work in Progress',
    'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/'\
        'Scripts/Import-Export/DXF_Importer',
    'tracker_url': 'https://projects.blender.org/tracker/index.php?'\
        'func=detail&aid=23480',
    'support': 'OFFICIAL',
    'category': 'Import-Export',
    }

"""
Release note by migius (DXF support maintainer) 2011.01.02:
Script supports only a small part of DXF specification:
- imports LINE, ARC, CIRCLE, ELLIPSE, SOLID, TRACE, POLYLINE, LWPOLYLINE
- imports TEXT, MTEXT
- supports 3d-rotation of entities (210 group)
- supports THICKNESS for SOLID, TRACE, LINE, ARC, CIRCLE, ELLIPSE
- ignores WIDTH, THICKNESS, BULGE in POLYLINE/LWPOLYLINE
- ignores face-data in POLYFACE / POLYMESH
- ignores TEXT 2d-rotation
- ignores hierarchies (BLOCK, INSERT, GROUP)
- ignores LAYER
- ignores COLOR, LINEWIDTH, LINESTYLE

This script is a temporary solution.
Probably no more improvements will be done to this script.
The full-feature importer script from 2.49 will be back in 2.6 release.

Installation:
Place this file to Blender addons directory
  (on Windows it is %Blender_directory%\2.53\scripts\addons\)
You must activate the script in the "Add-Ons" tab (user preferences).
Access it from File > Import menu.

History:
ver 0.1.5 - 2011.02.05 by migius for r.34661
- changed support level to OFFICIAL
- fixed missing last point at building Mesh-ARCs (by pildanovak)
- fixed for changes in API and mathutils by campbell
ver 0.1.4 - 2011.01.13 by migius
- modified for latest API in rev.34300 (by Filiciss Muhgue)
ver 0.1.3 - 2011.01.02 by migius
- added draw curves as sequence for "Draw_as_Curve"
- added toggle "Draw as one" as user preset in UI
- added draw POINT as mesh-vertex
- added draw_THICKNESS for LINE, ARC, CIRCLE, ELLIPSE, LWPOLYLINE and POLYLINE
- added draw_THICKNESS for SOLID, TRACE
ver 0.1.2 - 2010.12.27 by migius
- added draw() for TRACE
- fixed wrong vertex order in SOLID
- added CIRCLE resolution as user preset in UI
- added closing segment for circular LWPOLYLINE and POLYLINE
- fixed registering for 2.55beta
ver 0.1.1 - 2010.09.07 by migius
- fixed dxf-file names recognition limited to ".dxf"
- fixed registering for 2.53beta
ver 0.1 - 2010.06.10 by Thomas Larsson
"""

__version__ = '.'.join([str(s) for s in bl_info['version']])

import os
import codecs
import math
from math import sin, cos, radians
import bpy
import mathutils
from mathutils import Vector, Matrix

#
#    Global flags
#

T_Merge = 0x01
T_NewScene = 0x02
T_Curves = 0x04
T_DrawOne = 0x08
T_Debug = 0x10
T_Verbose = 0x20
T_ThicON = 0x40

toggle = T_Merge | T_NewScene | T_DrawOne | T_ThicON
theCircleRes = 32
theMergeLimit = 1e-5

#
#    class CSection:
#

class CSection:
    type = None

    def __init__(self):
        self.data = []

    def display(self):
        print("Section", self.type)
        for datum in self.data:
            datum.display()

#
#    class CTable:
#

class CTable:
    def __init__(self):
        self.type = None
        self.name = None
        self.handle = None
        self.owner = None
        self.subclass = None
        self.nEntries = 0
    def display(self):
        print("Table %s %s %s %s %s %d" % (self.type, self.name, self.handle, self.owner, self.subclass, self.nEntries))

#
#    class CEntity:
#
class CEntity:
    def __init__(self, typ, drawtype):
        self.type = typ
        self.drawtype = drawtype
        self.handle = None
        self.owner = None
        self.subclass = None
        self.layer = 0
        self.color = 0
        self.invisible = 0
        self.linetype_name = ''
        self.linetype_scale = 1.0
        self.paperspace = 0
        #self.normal = Vector((0,0,1))

    def display(self):
        print("Entity %s %s %s %s %s %s %x" % 
            (self.type, self.handle, self.owner, self.subclass, self.layer, self.color, self.invisible))

    def build(self, vn=0):
        global toggle
        if toggle & T_Debug:
            raise NameError("Warning: can not build - unsupported entity type: %s" % self.type)
        return(([], [], [], vn)) 

    def draw(self):
        global toggle
        if toggle & T_Debug:
            raise NameError("Warning: can not draw - unsupported entity type: %s" % self.type)
        return


DxfCommonAttributes = {
    5 : 'handle',
    6 : 'linetype_name',
    8 : 'layer',
    48 : 'linetype_scale',
    60 : 'invisible',
    62 : 'color',
    67 : 'paperspace',
    100 : 'subclass',
    330 : 'owner',
    360 : 'owner',
}

#
#    class C3dFace(CEntity):
#    10 : 'point0.x', 20 : 'point0.y', 30 : 'point0.z', 
#    11 : 'point1.x', 21 : 'point1.y', 31 : 'point1.z', 
#    12 : 'point2.x', 22 : 'point2.y', 32 : 'point2.z', 
#    13 : 'point3.x', 23 : 'point3.y', 33 : 'point3.z', 
#    70 : 'flags',
#

class C3dFace(CEntity):
    def __init__(self):
        CEntity.__init__(self, '3DFACE', 'Mesh')
        self.point0 = Vector()
        self.point1 = Vector()
        self.point2 = Vector()
        self.point3 = Vector()

    def display(self):
        CEntity.display(self)
        print(self.point0)
        print(self.point1)
        print(self.point2)
        print(self.point3)

    def build(self, vn=0):
        verts = [self.point0, self.point1, self.point2]
        if self.point3 == Vector((0,0,0)) or self.point2 == self.point3:
            faces = [(vn+0, vn+1, vn+2)]
            vn += 3
        else:
            verts.append( self.point3 )
            faces = [(vn+0, vn+1, vn+2, vn+3)]
            vn += 4            
        return((verts, [], faces, vn))

#
#    class C3dSolid(CEntity):
#    1 : 'data', 3 : 'more', 70 : 'version',
#

class C3dSolid(CEntity):
    def __init__(self):
        CEntity.__init__(self, '3DSOLID', 'Mesh')
        self.data = None
        self.more = None
        self.version = 0

#
#    class CAcadProxyEntity(CEntity):
#    70 : 'format',
#    90 : 'id', 91 : 'class', 92 : 'graphics_size', 93 : 'entity_size', 95: 'format',
#    310 : 'data', 330 : 'id1', 340 : 'id2', 350 : 'id3', 360 : 'id4', 
#

class CAcadProxyEntity(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'ACAD_PROXY_ENTITY', None)


#
#    class CArc(CEntity):
#    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
#    40 : 'radius',
#    50 : 'start_angle', 51 : 'end_angle'
#

class CArc(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'ARC', 'Mesh')
        self.center = Vector()
        self.radius = 0.0
        self.start_angle = 0.0
        self.end_angle = 0.0
        self.thickness = 0.0
        self.normal = Vector((0,0,1))
        
    def display(self):
        CEntity.display(self)
        print(self.center)
        print("%.4f %.4f %.4f " % (self.radius, self.start_angle, self.end_angle))

    def build(self, vn=0):
        start, end = self.start_angle, self.end_angle
        if end > 360: end = end % 360.0
        if end < start: end +=360.0
        angle = end - start

        deg2rad = math.pi/180.0
        start *= deg2rad
        end *= deg2rad
        dphi = end - start
        phi0 = start
        w = dphi/theCircleRes
        r = self.radius
        center = self.center
        v0 = vn
        points = []
        edges, faces = [], []
        for n in range(theCircleRes + 1):
            s = math.sin(n*w + phi0)
            c = math.cos(n*w + phi0)
            v = center + Vector((r*c, r*s, 0.0))
            points.append(v)
        pn = len(points)
        thic = self.thickness
        t_vector = Vector((0, 0, thic))
        if thic != 0 and (toggle & T_ThicON):
            thic_points = [v + t_vector for v in points]
            if thic < 0.0:
                thic_points.extend(points)
                points = thic_points
            else:
                points.extend(thic_points)
            faces = [(v0+nr+0,v0+nr+1,v0+pn+nr+1,v0+pn+nr+0) for nr in range(pn)]
            faces.pop()
            self.drawtype = 'Mesh'
            vn += 2*pn
        else:
            edges = [(v0+nr+0,v0+nr+1) for nr in range(pn)]
            edges.pop()
            vn += pn

        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                #ma.invert()
                points = [v * ma for v in points]
        #print ('arc vn=', vn)
        #print ('faces=', len(faces))
        return ((points, edges, faces, vn))

#
#    class CArcAlignedText(CEntity):
#    1 : 'text', 2 : 'font', 3 : 'bigfont', 7 : 'style',
#    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
#    40 : 'radius', 41 : 'width', 42 : 'height', 43 : 'spacing', 
#    44 : 'offset', 45 : 'right_offset', 46 : 'left_offset', 
#    50 : 'start_angle', 51 : 'end_angle',
#    70 : 'order', 71 : 'direction', 72 : 'alignment', 73 : 'side', 
#    74 : 'bold', 75 : 'italic', 76 : 'underline',
#    77 : 'character_set', 78 : 'pitch', 79 'fonttype',
#    90 : 'color',
#    280 : 'wizard', 330 : 'id'
#

class CArcAlignedText(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'ARCALIGNEDTEXT', 'Mesh')
        self.text = ""
        self.style = ""
        self.center = Vector()
        self.radius = 0.0
        self.width = 1.0
        self.height = 1.0
        self.spacing = 1.0
        self.offset = 0.0
        self.right_offset = 0.0
        self.left_offset = 0.0
        self.start_angle = 0.0
        self.end_angle = 0.0
        self.order = 0
        self.directions = 0
        self.alignment = 0
        self.side = 0
        self.bold = 0
        self.italic = 0
        self.underline = 0
        self.character_set = 0
        self.pitch = 0
        self.fonttype = 0
        self.color = 0
        self.wizard = None
        self.id = None
        self.normal = Vector((0,0,1))


#
#    class CAttdef(CEntity):
#    1 : 'text', 2 : 'tag', 3 : 'prompt', 7 : 'style',
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
#    40 : 'height', 41 : 'x_scale', 
#    50 : 'rotation_angle', 51 : 'oblique_angle', 
#    70 : 'flags', 71 : 'text_generation_flags', 
#    72 : 'horizontal_justification',  74 : 'vertical_justification',    
#

class CAttdef(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'ATTDEF', None)
        self.value = ""
        self.tag = ""
        self.prompt = ""
        self.style = ""
        self.insertion_point = Vector()
        self.alignment_point = Vector()
        self.height = 1.0
        self.x_scale = 1.0
        self.rotation_angle = 0.0
        self.oblique_angle = 0.0
        self.flags = 0
        self.text_generation_flags = 0
        self.horizontal_justification = 0.0
        self.vertical_justification = 0.0
        self.normal = Vector((0,0,1))

    def draw(self):
        drawText(self.text,  self.insertion_point, self.height, self.x_scale, self.rotation_angle, self.oblique_angle, self.normal)
        return

#
#    class CAttrib(CEntity):
#    1 : 'text', 2 : 'tag', 3 : 'prompt', 7 : 'style',
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
#    40 : 'height', 41 : 'x_scale', 
#    50 : 'rotation_angle', 51 : 'oblique_angle', 
#    70 : 'flags', 73 : 'length', 
#    71 : 'text_generation_flags', 72 : 'horizontal_justification',  74 : 'vertical_justification',     
#

class CAttrib(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'ATTRIB', None)
        self.text = ""
        self.tag = ""
        self.prompt = ""

        self.style = ""
        self.insertion_point = Vector()
        self.alignment_point = Vector()
        self.height = 1.0
        self.x_scale = 1.0
        self.rotation_angle = 0.0
        self.oblique_angle = 0.0
        self.flags = 0
        self.length = 1.0
        self.text_generation_flags = 0
        self.horizontal_justification = 0.0
        self.vertical_justification = 0.0
        self.normal = Vector((0,0,1))

    def draw(self):
        drawText(self.text,  self.insertion_point, self.height, self.x_scale, self.rotation_angle, self.oblique_angle, self.normal)
        return


#
#    class CBlock(CEntity):
#    1 : 'xref', 2 : 'name', 3 : 'also_name', 
#    10 : 'base_point.x', 20 : 'base_point.y', 30 : 'base_point.z', 
#    40 : 'size', 41 : 'x_scale', 
#    50 : 'rotation_angle', 51 : 'oblique_angle',     
#    70 : 'flags', 
#

class CBlock(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'BLOCK', None)
        self.xref = ""
        self.name = ""
        self.also_name = ""
        self.base_point = Vector()
        self.size = 1.0
        self.x_scale = 1.0
        self.rotation_angle = 0.0
        self.oblique_angle = 0.0
        self.flags = 0
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print("%s %s %s " % (self.xref, self.name, self.also_name))
        print(self.base_point)

    def draw(self):
        # Todo
        return

#
#    class CCircle(CEntity):
#    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
#    40 : 'radius'
#

class CCircle(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'CIRCLE', 'Mesh')
        self.center = Vector()
        self.radius = 0.0
        self.thickness = 0.0
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print(self.center)
        print("%.4f" % self.radius)

    def build(self, vn=0):
        w = 2*math.pi/theCircleRes
        r = self.radius
        center = self.center
        points = []
        edges, faces = [], []
        v0 = vn
        for n in range(theCircleRes):
            s = math.sin(n*w)
            c = math.cos(n*w)
            v = center + Vector((r*c, r*s, 0))
            points.append(v)

        pn = len(points)
        thic = self.thickness
        t_vector = Vector((0, 0, thic))
        if thic != 0 and (toggle & T_ThicON):
            thic_points = [v + t_vector for v in points]
            if thic < 0.0:
                thic_points.extend(points)
                points = thic_points
            else:
                points.extend(thic_points)
            faces = [(v0+nr,v0+nr+1,pn+v0+nr+1,pn+v0+nr) for nr in range(pn)]
            nr = pn -1
            faces[-1] = (v0+nr,v0,pn+v0,pn+v0+nr)
            self.drawtype = 'Mesh'
            vn += 2*pn
        else:
            edges = [(v0+nr,v0+nr+1) for nr in range(pn)]
            nr = pn -1
            edges[-1] = (v0+nr,v0)
            vn += pn
        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                #ma.invert()
                points = [v * ma for v in points]
        #print ('cir vn=', vn)
        #print ('faces=',len(faces))
        return( (points, edges, faces, vn) )
            
#
#    class CDimension(CEntity):
#    1 : 'text', 2 : 'name', 3 : 'style',
#    10 : 'def_point.x', 20 : 'def_point.y', 30 : 'def_point.z', 
#    11 : 'mid_point.x', 21 : 'mid_point.y', 31 : 'mid_point.z', 
#    12 : 'vector.x', 22 : 'vector.y', 32 : 'vector.z', 
#    13 : 'def_point2.x', 23 : 'def_point2.y', 33 : 'def_point2.z', 
#    14 : 'vector2.x', 24 : 'vector2.y', 34 : 'vector2.z', 
#    15 : 'vector3.x', 25 : 'vector3.y', 35 : 'vector3.z', 
#    16 : 'vector4.x', 26 : 'vector4.y', 36 : 'vector4.z', 
#    70 : 'dimtype',
#

class CDimension(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'DIMENSION', None)
        self.text = ""
        self.name = ""
        self.style = ""
        self.def_point = Vector()
        self.mid_point = Vector()
        self.vector = Vector()
        self.def_point2 = Vector()
        self.vector2 = Vector()
        self.vector3 = Vector()
        self.vector4 = Vector()
        self.dimtype = 0
        self.normal = Vector((0,0,1))

    def draw(self):
        return

#
#    class CEllipse(CEntity):
#    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
#    11 : 'end_point.x', 21 : 'end_point.y', 31 : 'end_point.z', 
#    40 : 'ratio', 41 : 'start', 42 : 'end',
#

class CEllipse(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'ELLIPSE', 'Mesh')
        self.center = Vector()
        self.end_point = Vector()
        self.ratio = 1.0
        self.start = 0.0
        self.end = 2*math.pi
        self.thickness = 0.0
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print(self.center)
        print("%.4f" % self.ratio)
                
    def build(self, vn=0):
        dphi = (self.end - self.start)
        phi0 = self.start
        w = dphi/theCircleRes
        r = self.end_point.length
        f = self.ratio
        a = self.end_point.x/r
        b = self.end_point.y/r
        center = self.center
        v0 = vn
        points = []
        edges, faces = [], []
        for n in range(theCircleRes):
            x = r*math.sin(n*w + phi0)
            y = f*r*math.cos(n*w + phi0)
            v = (center.x - a*x + b*y, center.y - a*y - b*x, center.z)
            points.append(v)

        pn = len(points)
        thic = self.thickness
        t_vector = Vector((0, 0, thic))
        if thic != 0 and (toggle & T_ThicON):
            thic_points = [v + t_vector for v in points]
            if thic < 0.0:
                thic_points.extend(points)
                points = thic_points
            else:
                points.extend(thic_points)
            faces = [(v0+nr,v0+nr+1,pn+v0+nr+1,pn+v0+nr) for nr in range(pn)]
            nr = pn -1
            faces[-1] = (v0+nr,v0,pn+v0,pn+v0+nr)
            #self.drawtype = 'Mesh'
            vn += 2*pn
        else:
            edges = [(v0+nr,v0+nr+1) for nr in range(pn)]
            nr = pn -1
            edges[-1] = (v0+nr,v0)
            vn += pn


        if thic != 0 and (toggle & T_ThicON):
            pass
        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                #ma.invert()
                points = [v * ma for v in points]
        return ((points, edges, faces, vn))

#
#    class CHatch(CEntity):
#    2 : 'pattern',
#    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
#    41 : 'scale', 47 : 'pixelsize', 52 : 'angle',
#    70 : 'fill', 71 : 'associativity', 75: 'style', 77 : 'double', 
#    78 : 'numlines', 91 : 'numpaths', 98 : 'numseeds',
#

class CHatch(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'HATCH', None)
        self.pattern = 0
        self.point = Vector()
        self.scale = 1.0
        self.pixelsize = 1.0
        self.angle = 0.0
        self.fill = 0
        self.associativity = 0
        self.style = 0
        self.double = 0
        self.numlines = 0
        self.numpaths = 0
        self.numseeds = 0
        self.normal = Vector((0,0,1))


#    class CImage(CEntity):
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    11 : 'u_vector.x', 21 : 'u_vector.y', 31 : 'u_vector.z', 
#    12 : 'v_vector.x', 22 : 'v_vector.y', 32 : 'v_vector.z', 
#    13 : 'size.x', 23 : 'size.y', 33 : 'size.z', 
#    14 : 'clip.x', 24 : 'clip.y', 34 : 'clip.z', 
#    70 : 'display', 71 : 'cliptype', 
#    90 : 'version',
#    280 : 'clipstate', 281 : 'brightness', 282 : 'contrast', 283 : 'fade', 
#    340 : 'image', 360 : 'reactor'
#

class CImage(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'IMAGE', None)
        self.insertion_point = Vector()
        self.u_vector = Vector()
        self.v_vector = Vector()
        self.size = Vector()
        self.clip = Vector()
        self.display = 0
        self.cliptype = 0
        self.version = 1
        self.clipstate = 0
        self.brightness = 0
        self.constrast = 0
        self.fade = 0
        self.image = None
        self.reactor = None
        self.normal = Vector((0,0,1))

#
#    class CInsert(CEntity):
#    1 : 'attributes_follow', 2 : 'name',
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    41 : 'x_scale', 42 : 'y_scale', 43 : 'z_scale', 
#    44 : 'column_spacing', 45 : 'row_spacing', 
#    50 : 'rotation_angle', 66 : 'attributes_follow',
#    70 : 'column_count', 71 : 'row_count', 
#

class CInsert(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'INSERT', None)
        self.attributes_follow = 1
        self.name = ""
        self.insertion_point = Vector()
        self.x_scale = 1.0
        self.y_scale = 1.0
        self.z_scale = 1.0
        self.column_spacing = 1.0
        self.row_spacing = 1.0
        self.rotation_angle = 0.0
        self.column_count = 1
        self.row_count = 1
        self.attributes_follow = 0
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print(self.insertion_point)

    def draw(self):
        # Todo
        return

#
#    class CLeader(CEntity):
#    3 : 'style',
#    10 : ['new_vertex(data)'], 20 : 'vertex.y', 30 : 'vertex.z', 
#    40 : 'height', 41 : 'width',
#    71 : 'arrowhead', 72 : 'pathtype', 73 : 'creation', 
#    74 : 'hookdir', 75 : 'hookline', 76 : 'numverts', 77 : 'color',
#    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
#    211 : 'horizon.x', 221 : 'horizon.y', 231 : 'horizon.z', 
#    212 : 'offset_ins.x', 222 : 'offset_ins.y', 232 : 'offset_ins.z', 
#    213 : 'offset_ann.x', 223 : 'offset_ann.y', 233 : 'offset_ann.z', 
#

class CLeader(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'LEADER', 'Mesh')
        self.style = ""
        self.vertex = None
        self.verts = []
        self.height = 1.0
        self.width = 1.0
        self.arrowhead = 0
        self.pathtype = 0
        self.creation = 0
        self.hookdir = 0
        self.hookline = 0
        self.numverts = 0
        self.color = 0
        self.normal = Vector((0,0,1))
        self.horizon = Vector()
        self.offset_ins = Vector()
        self.offset_ann = Vector()

    def new_vertex(self, data):
        self.vertex = Vector()
        self.vertex.x = data
        self.verts.append(self.vertex)

    def build(self, vn=0):
        edges = []
        for v in self.verts:
            edges.append((vn, vn+1))
            vn += 1
        edges.pop()
        return (self.verts, edges, [], vn)

#    class CLwPolyLine(CEntity):
#    10 : ['new_vertex(data)'], 20 : 'vertex.y', 30 : 'vertex.z', 
#    38 : 'elevation', 39 : 'thickness',
#    40 : 'start_width', 41 : 'end_width', 42 : 'bulge', 43 : 'constant_width',
#    70 : 'flags', 90 : 'numverts'
#

class CLWPolyLine(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'LWPOLYLINE', None)
        self.vertex = None
        self.verts = []
        self.elevation = 0
        self.thickness = 0.0
        self.start_width = 0.0
        self.end_width = 0.0
        self.bulge = 0.0
        self.constant_width = 0.0
        self.flags = 0
        self.numverts = 0
        self.normal = Vector((0,0,1))

    def new_vertex(self, data):
        self.vertex = Vector()
        self.vertex.x = data
        self.verts.append(self.vertex)

    def build(self, vn=0):
        edges = []
        v_start = vn
        for v in self.verts:
            edges.append((vn, vn+1))
            vn += 1
        if self.flags & PL_CLOSED:
            edges[-1] = (vn-1, v_start)
        else:
            edges.pop()
        verts = self.verts
        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                #ma.invert()
                verts = [v * ma for v in verts]
        return (verts, edges, [], vn-1)
        
#
#    class CLine(CEntity):
#    10 : 'start_point.x', 20 : 'start_point.y', 30 : 'start_point.z', 
#    11 : 'end_point.x', 21 : 'end_point.y', 31 : 'end_point.z', 
#    39 : 'thickness',
#

class CLine(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'LINE', 'Mesh')
        self.start_point = Vector()
        self.end_point = Vector()
        self.thickness = 0.0
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print(self.start_point)
        print(self.end_point)

    def build(self, vn=0):
        points = [self.start_point, self.end_point]
        faces, edges = [], []
        n = vn
        thic = self.thickness
        if thic != 0 and (toggle & T_ThicON):
            t_vector = thic * self.normal
            #print 'deb:thic_vector: ', t_vector #---------------------
            points.extend([v + t_vector for v in points])
            faces = [[0+n, 1+n, 3+n, 2+n]]
            self.drawtype = 'Mesh'
        else:
            edges = [[0+n, 1+n]]
        vn +=2
        return((points, edges, faces, vn))

#    class CMLine(CEntity):
#    10 : 'start_point.x', 20 : 'start_point.y', 30 : 'start_point.z', 
#    11 : ['new_vertex(data)'], 21 : 'vertex.y', 31 : 'vertex.z', 
#    12 : ['new_seg_dir(data)'], 22 : 'seg_dir.y', 32 : 'seg_dir.z', 
#    13 : ['new_miter_dir(data)'], 23 : 'miter_dir.y', 33 : 'miter_dir.z', 
#    40 : 'scale', 41 : 'elem_param', 42 : 'fill_param',
#    70 : 'justification', 71 : 'flags'
#    72 : 'numverts', 73 : 'numelems', 74 : 'numparam', 75 : 'numfills',
#    340 : 'id'
#

class CMLine(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'MLINE', None)
        self.start_point = Vector()
        self.vertex = None
        self.seg_dir = None
        self.miter_dir = None
        self.verts = []
        self.seg_dirs = []
        self.miter_dirs = []
        self.scale = 1.0
        self.elem_param = 0
        self.fill_param = 0
        self.justification = 0
        self.flags = 0
        self.numverts = 0
        self.numelems = 0
        self.numparam = 0
        self.numfills = 0
        self.id = 0
        self.normal = Vector((0,0,1))

    def new_vertex(self, data):
        self.vertex = Vector()
        self.vertex.x = data
        self.verts.append(self.vertex)

    def new_seg_dir(self, data):
        self.seg_dir = Vector()
        self.seg_dir.x = data
        self.seg_dirs.append(self.seg_dir)

    def new_miter_dir(self, data):
        self.miter_dir = Vector()
        self.miter_dir.x = data
        self.miter_dirs.append(self.miter_dir)



#
#    class CMText(CText):
#    1 : 'text', 3: 'more_text', 7 : 'style',
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
#    40 : 'nominal_height', 41 : 'reference_width', 42: 'width', 43 : 'height', 44 : 'line_spacing',
#    50 : 'rotation_angle', 
#    71 : 'attachment_point', 72 : 'drawing_direction',  73 : 'spacing_style',    
#

class CMText(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'MTEXT', 'Text')
        self.text = ""
        self.more_text = ""
        self.style = ""
        self.insertion_point = Vector()
        self.alignment_point = Vector()
        self.nominal_height = 1.0
        self.reference_width = 1.0
        self.width = 1.0
        self.height = 1.0
        self.rotation_angle = 0.0
        self.attachment_point = 0
        self.drawing_direction = 0
        self.spacing_style = 0
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print("%s %s" % (self.text, self.style))
        print('MTEXTinsertion_point=',self.insertion_point)
        print('MTEXTalignment_point=',self.alignment_point)

    def draw(self):
        drawText(self.text,  self.insertion_point, self.height, self.width, self.rotation_angle, 0.0, self.normal)
        return

#
#    class CPoint(CEntity):
#    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
#    39 : 'thickness', 50 : 'orientation'
#

class CPoint(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'POINT', 'Mesh')
        self.point = Vector()
        self.thickness = 0.0
        self.orientation = 0.0

    def display(self):
        CEntity.display(self)
        print(self.point)
        print("%.4f" % self.orientation)

    def build(self, vn=0):
        # draw as mesh-vertex
        verts = [self.point]
        return((verts, [], [], vn+1))

    def draw(self):
        #todo
        # draw as empty-object
        loc = self.point
        #bpy.ops.object.new('DXFpoint')

#
#    class CPolyLine(CEntity):
#    1 : 'verts_follow', 2 : 'name',
#    10 : 'elevation.x', 20 : 'elevation.y', 30 : 'elevation.z', 
#    40 : 'start_width', 41 : 'end_width', 
#    66 : 'verts_follow_flag',
#    70 : 'flags', 71 : 'row_count', 72 : 'column_count', 
#    73 : 'row_density', 74 : 'column_density', 75 : 'linetype',
#

class CPolyLine(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'POLYLINE', 'Mesh')
        self.verts = []
        self.verts_follow = 1
        self.name = ""
        self.elevation = Vector()
        self.thickness = 0.0
        self.start_width = 0.0
        self.end_width = 0.0
        self.verts_follow_flags = 0
        self.flags = 0
        self.row_count = 1
        self.column_count = 1
        self.row_density = 1.0
        self.column_density = 1.0
        self.linetype = 1
        self.normal = Vector((0,0,1))

    def display(self):
        CEntity.display(self)
        print("VERTS")
        for v in self.verts:
            print(v.location)
        print("END VERTS")

    def build(self, vn=0):
        verts = []
        lines = []
        v_start = vn
        for vert in self.verts:
            verts.append(vert.location)
            lines.append((vn, vn+1))
            vn += 1
        if self.flags & PL_CLOSED:
            lines[-1] = (vn-1, v_start)
        else:
            lines.pop()
        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                verts = [v * ma for v in verts]
        return((verts, lines, [], vn-1))

#
#    class CShape(CEntity):
#    2 : 'name', 
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    39 : 'thickness',
#    40 : 'size', 41 : 'x_scale', 
#    50 : 'rotation_angle', 51 : 'oblique_angle',     
#

class CShape(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'SHAPE', None)
        self.name = ""
        self.insertion_point = Vector()
        self.thickness = 0.0
        self.size = 1.0
        self.x_scale = 1.0
        self.rotation_angle = 0.0
        self.oblique_angle = 0.0

    def display(self):
        CEntity.display(self)
        print("%s" % (self.name))
        print(self.insertion_point)

#
#    class CSpline(CEntity):
#    10 : ['new_control_point(data)'], 20 : 'control_point.y', 30 : 'control_point.z', 
#    11 : ['new_fit_point(data)'], 21 : 'fit_point.y', 31 : 'fit_point.z', 
#    40 : ['new_knot_value(data)'], 
#    12 : 'start_tangent.x', 22 : 'start_tangent.y', 32 : 'start_tangent.z', 
#    13 : 'end_tangent.x', 23 : 'end_tangent.y', 33 : 'end_tangent.z', 
#    41 : 'weight', 42 : 'knot_tol', 43 : 'control_point_tol', 44 : 'fit_tol',
#    70 : 'flag', 71 : 'degree', 
#    72 : 'num_knots', 73 : 'num_control_points', 74 : 'num_fit_points',
#    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
#

class CSpline(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'SPLINE', 'Mesh')
        self.control_points = []
        self.fit_points = []
        self.knot_values = []
        self.control_point = None
        self.fit_point = None
        self.knot_value = None
        self.start_tangent = Vector()
        self.end_tangent = Vector()
        self.weight = 1.0
        self.knot_tol = 1e-6
        self.control_point_tol = 1e-6
        self.fit_tol = 1e-6
        self.flag = 0
        self.degree = 3
        self.num_knots = 0
        self.num_control_points = 0
        self.num_fit_points = 0
        self.thickness = 0.0
        self.normal = Vector((0,0,1))
        
    def new_control_point(self, data):
        self.control_point = Vector()
        self.control_point.x = data
        self.control_points.append(self.control_point)
        
    def new_fit_point(self, data):
        self.fit_point = Vector()
        self.fit_point.x = data
        self.fit_points.append(self.fit_point)

    def new_knot_value(self, data):
        self.knot_value = data
        self.knot_values.append(self.knot_value)
        
    def display(self):
        #not testet yet (migius)
        CEntity.display(self)
        print("CONTROL")
        for p in self.control_points:
            print(p)
        print("FIT")
        for p in self.fit_points:
            print(p)
        print("KNOT")
        for v in self.knot_values:
            print(v)

    def build(self, vn=0):
        verts = []
        lines = []
        for vert in self.control_points:
            verts.append(vert)
            lines.append((vn, vn+1))
            vn += 1
        lines.pop()
        return((verts, lines, [], vn))


#
#    class CSolid(CEntity):
#    10 : 'point0.x', 20 : 'point0.y', 30 : 'point0.z', 
#    11 : 'point1.x', 21 : 'point1.y', 31 : 'point1.z', 
#    12 : 'point2.x', 22 : 'point2.y', 32 : 'point2.z', 
#    13 : 'point3.x', 23 : 'point3.y', 33 : 'point3.z', 
#    39 : 'thickness',
#

class CSolid(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'SOLID', 'Mesh')
        self.point0 = Vector()
        self.point1 = Vector()
        self.point2 = Vector()
        self.point3 = Vector()
        self.normal = Vector((0,0,1))
        self.thickness = 0.0
        
    def display(self):
        CEntity.display(self)
        print(self.point0)
        print(self.point1)
        print(self.point2)
        print(self.point3)

    def build(self, vn=0):
        points, edges, faces = [],[],[]
        if self.point2 == self.point3:
            points = [self.point0, self.point1, self.point2]
        else:
            points = [self.point0, self.point1, self.point2, self.point3]
        pn = len(points)
        v0 = vn
        
        thic = self.thickness
        t_vector = Vector((0, 0, thic))
        if thic != 0 and (toggle & T_ThicON):
            thic_points = [v + t_vector for v in points]
            if thic < 0.0:
                thic_points.extend(points)
                points = thic_points
            else:
                points.extend(thic_points)

            if   pn == 4:
                faces = [[0,1,3,2], [4,6,7,5], [0,4,5,1],
                         [1,5,7,3], [3,7,6,2], [2,6,4,0]]
            elif pn == 3:
                faces = [[0,1,2], [3,5,4], [0,3,4,1], [1,4,5,2], [2,5,3,0]]
            elif pn == 2: faces = [[0,1,3,2]]
            vn += 2*pn
        else:
            if   pn == 4: faces = [[0,2,3,1]]
            elif pn == 3: faces = [[0,2,1]]
            elif pn == 2:
                edges = [[0,1]]
                self.drawtype = 'Mesh'
            vn += pn
        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                points = [v * ma for v in points]
        return((points, edges, faces, vn))
        
#
#    class CText(CEntity):
#    1 : 'text', 7 : 'style',
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
#    40 : 'height', 41 : 'x_scale', 
#    50 : 'rotation_angle', 51 : 'oblique_angle', 
#    71 : 'flags', 72 : 'horizontal_justification',  73 : 'vertical_justification',    
#

class CText(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'TEXT', 'Text')
        self.text = ""
        self.style = ""
        self.insertion_point = Vector()
        self.alignment_point = Vector()
        self.height = 1.0
        self.x_scale = 1.0
        self.rotation_angle = 0.0
        self.oblique_angle = 0.0
        self.flags = 0
        self.horizontal_justification = 0.0
        self.vertical_justification = 0.0
        self.thickness = 0.0
        self.normal = Vector((0,0,1))
       
    def display(self):
        CEntity.display(self)
        print("%s %s" % (self.text, self.style))
        print(self.insertion_point)
        print(self.alignment_point)
        
    def draw(self):
        drawText(self.text,  self.insertion_point, self.height, self.x_scale, self.rotation_angle, self.oblique_angle, self.normal)
        return


def drawText(text, loc, size, spacing, angle, shear, normal=Vector((0,0,1))):
        #print('angle_deg=',angle)
        bpy.ops.object.text_add(
            view_align=False, 
            enter_editmode=False, 
            location= loc, 
            #rotation=(0, 0, angle), #need radians here
            )
        cu = bpy.context.object.data
        cu.body = text
        cu.size = size #up 2.56
        cu.space_word = spacing #up 2.56
        cu.shear = shear
        if angle!=0.0 or normal!=Vector((0,0,1)):
            obj = bpy.context.object
            transform(normal, angle, obj)
        return

#
#    class CTolerance(CEntity):
#    3 : 'style',
#    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
#    11 : 'direction.x', 21 : 'direction.y', 31 : 'direction.z', 
#

class CTolerance(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'TOLERANCE', None)
        self.stype = ""
        self.insertion_point = Vector()
        self.direction = Vector()

#
#    class CTrace(CEntity):
#    10 : 'point0.x', 20 : 'point0.y', 30 : 'point0.z', 
#    11 : 'point1.x', 21 : 'point1.y', 31 : 'point1.z', 
#    12 : 'point2.x', 22 : 'point2.y', 32 : 'point2.z', 
#    13 : 'point3.x', 23 : 'point3.y', 33 : 'point3.z', 
#    39 : 'thickness',
#

class CTrace(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'TRACE', 'Mesh')
        self.point0 = Vector()
        self.point1 = Vector()
        self.point2 = Vector()
        self.point3 = Vector()
        self.normal = Vector((0,0,1))
        self.thickness = 0.0
    
    def display(self):
        CEntity.display(self)
        print(self.point0)
        print(self.point1)
        print(self.point2)
        print(self.point3)
   
    def build(self, vn=0):
        points, edges, faces = [],[],[]
        if self.point2 == self.point3:
            points = [self.point0, self.point2, self.point1]
        else:
            points = [self.point0, self.point2, self.point1, self.point3]
        pn = len(points)
        v0 = vn
        thic = self.thickness
        t_vector = Vector((0, 0, thic))
        if thic != 0 and (toggle & T_ThicON):
            thic_points = [v + t_vector for v in points]
            if thic < 0.0:
                thic_points.extend(points)
                points = thic_points
            else:
                points.extend(thic_points)

            if   pn == 4:
                faces = [[0,1,3,2], [4,6,7,5], [0,4,5,1],
                         [1,5,7,3], [3,7,6,2], [2,6,4,0]]
            elif pn == 3:
                faces = [[0,1,2], [3,5,4], [0,3,4,1], [1,4,5,2], [2,5,3,0]]
            elif pn == 2: faces = [[0,1,3,2]]
            vn += 2*pn
        else:
            if   pn == 4: faces = [[0,2,3,1]]
            elif pn == 3: faces = [[0,2,1]]
            elif pn == 2:
                edges = [[0,1]]
                self.drawtype = 'Mesh'
        if self.normal!=Vector((0,0,1)):
            ma = getOCS(self.normal)
            if ma:
                points = [v * ma for v in points]
        return ((points, edges, faces, vn))

#
#    class CVertex(CEntity):
#    10 : 'location.x', 20 : 'location.y', 30 : 'location.z', 
#    40 : 'start_width', 41 : 'end_width', 42 : 'bulge', 
#    50 : 'tangent',
#    70 : 'flags',
#    71 : 'index1', 72 : 'index2', 73 : 'index3', 74 : 'index4', 
#

class CVertex(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'VERTEX', None)
        self.location = Vector()
        self.start_width = 0.0
        self.end_width = 0.0
        self.bulge = 0.0
        self.tangent = 0.0
        self.flags = 0

    def display(self):
        return

    def draw(self):
        return

#            
#    class CViewPort(CEntity):
#    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
#    12 : 'view_center.x', 22 : 'view_center.y', 32 : 'view_center.z', 
#    13 : 'snap_base.x', 23 : 'snap_base.y', 33 : 'snap_base.z', 
#    14 : 'snap_spacing.x', 24 : 'snap_spacing.y', 34 : 'snap_spacing.z', 
#    15 : 'grid_spacing.x', 25 : 'grid_spacing.y', 35 : 'grid_spacing.z', 
#    16 : 'view_direction.x', 26 : 'view_direction.y', 36 : 'view_direction.z', 
#    40 : 'width', 41 : 'height',
#    68 : 'status', 69 : 'id',
#

class CViewPort(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'VIEWPORT', None)
        self.center = Vector()
        self.view_center = Vector()
        self.snap_base = Vector()
        self.snap_spacing = Vector()
        self.grid_spacing = Vector()
        self.view_direction = Vector()
        self.width = 1.0
        self.height = 1.0
        self.status = 0
        self.id = 0

    def draw(self):
        # Todo
        return

#
#    class CWipeOut(CEntity):
#    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
#    11 : 'direction.x', 21 : 'direction.y', 31 : 'direction.z', 
#

class CWipeOut(CEntity):
    def __init__(self):
        CEntity.__init__(self, 'WIPEOUT', None)
        self.point = Vector()
        self.direction = Vector()

#
#
#
WORLDX = Vector((1.0,0.0,0.0))
WORLDY = Vector((0.0,1.0,0.0))
WORLDZ = Vector((0.0,0.0,1.0))


def getOCS(az):  #-----------------------------------------------------------------
    """An implimentation of the Arbitrary Axis Algorithm.
    """
    #decide if we need to transform our coords
    #if az[0] == 0 and az[1] == 0: 
    if abs(az.x) < 0.00001 and abs(az.y) < 0.00001:
        if az.z > 0.0:
            return False
        elif az.z < 0.0:
            return Matrix((-WORLDX, WORLDY*1, -WORLDZ))

    cap = 0.015625 # square polar cap value (1/64.0)
    if abs(az.x) < cap and abs(az.y) < cap:
        ax = WORLDY.cross(az)
    else:
        ax = WORLDZ.cross(az)
    ax.normalize()
    ay = az.cross(ax)
    ay.normalize()
    return Matrix((ax, ay, az))



def transform(normal, rotation, obj):  #--------------------------------------------
    """Use the calculated ocs to determine the objects location/orientation in space.
    """
    ma = Matrix(((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)))
    o = Vector(obj.location)
    ma_new = getOCS(normal)
    if ma_new:
        ma = ma_new
        ma.resize_4x4()
        o = o * ma

    if rotation != 0:
        g = radians(-rotation)
        rmat = Matrix(((cos(g), -sin(g), 0), (sin(g), cos(g), 0), (0, 0, 1)))
        ma = ma * rmat.to_4x4()

    obj.matrix_world = ma #must be matrix4x4
    obj.location = o


DxfEntityAttributes = {
'3DFACE'    : {
    10 : 'point0.x', 20 : 'point0.y', 30 : 'point0.z', 
    11 : 'point1.x', 21 : 'point1.y', 31 : 'point1.z', 
    12 : 'point2.x', 22 : 'point2.y', 32 : 'point2.z', 
    13 : 'point3.x', 23 : 'point3.y', 33 : 'point3.z', 
    70 : 'flags',
    },

'3DSOLID'    : {
    1 : 'data', 3 : 'more', 70 : 'version',
    },

'ACAD_PROXY_ENTITY'    : {
    70 : 'format',
    90 : 'id', 91 : 'class', 92 : 'graphics_size', 93 : 'entity_size', 95: 'format',
    310 : 'data', 330 : 'id1', 340 : 'id2', 350 : 'id3', 360 : 'id4', 
    },

'ARC'        : {
    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
    40 : 'radius',
    50 : 'start_angle', 51 : 'end_angle',
    39 : 'thickness',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'ARCALIGNEDTEXT'    : {
    1 : 'text', 2 : 'font', 3 : 'bigfont', 7 : 'style',
    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
    40 : 'radius', 41 : 'width', 42 : 'height', 43 : 'spacing', 
    44 : 'offset', 45 : 'right_offset', 46 : 'left_offset', 
    50 : 'start_angle', 51 : 'end_angle',
    70 : 'order', 71 : 'direction', 72 : 'alignment', 73 : 'side', 
    74 : 'bold', 75 : 'italic', 76 : 'underline',
    77 : 'character_set', 78 : 'pitch', 79 : 'fonttype',
    90 : 'color',
    280 : 'wizard', 330 : 'id'
    },

'ATTDEF'    : {
    1 : 'text', 2 : 'tag', 3 : 'prompt', 7 : 'style',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
    40 : 'height', 41 : 'x_scale', 
    50 : 'rotation_angle', 51 : 'oblique_angle', 
    70 : 'flags', 71 : 'text_generation_flags', 
    72 : 'horizontal_justification',  74 : 'vertical_justification',    
    },


'ATTRIB'    : {
    1 : 'text', 2 : 'tag', 3 : 'prompt', 7 : 'style',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
    40 : 'height', 41 : 'x_scale', 
    50 : 'rotation_angle', 51 : 'oblique_angle', 
    70 : 'flags', 73 : 'length', 
    71 : 'text_generation_flags', 72 : 'horizontal_justification',  74 : 'vertical_justification',     
    },

'BLOCK'        : {
    1 : 'xref', 2 : 'name', 3 : 'also_name', 
    10 : 'base_point.x', 20 : 'base_point.y', 30 : 'base_point.z', 
    40 : 'size', 41 : 'x_scale', 
    50 : 'rotation_angle', 51 : 'oblique_angle',     
    70 : 'flags', 
    },

'CIRCLE'    : {
    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
    40 : 'radius',
    39 : 'thickness',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'DIMENSION'    : {
    1 : 'text', 2 : 'name', 3 : 'style',
    10 : 'def_point.x', 20 : 'def_point.y', 30 : 'def_point.z', 
    11 : 'mid_point.x', 21 : 'mid_point.y', 31 : 'mid_point.z', 
    12 : 'vector.x', 22 : 'vector.y', 32 : 'vector.z', 
    13 : 'def_point2.x', 23 : 'def_point2.y', 33 : 'def_point2.z', 
    14 : 'vector2.x', 24 : 'vector2.y', 34 : 'vector2.z', 
    15 : 'vector3.x', 25 : 'vector3.y', 35 : 'vector3.z', 
    16 : 'vector4.x', 26 : 'vector4.y', 36 : 'vector4.z', 
    70 : 'dimtype',
    },

'ELLIPSE'    : {
    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
    11 : 'end_point.x', 21 : 'end_point.y', 31 : 'end_point.z', 
    40 : 'ratio', 41 : 'start', 42 : 'end',
    39 : 'thickness',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'HATCH'        : {
    2 : 'pattern',
    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
    41 : 'scale', 47 : 'pixelsize', 52 : 'angle',
    70 : 'fill', 71 : 'associativity', 75: 'style', 77 : 'double', 
    78 : 'numlines', 91 : 'numpaths', 98 : 'numseeds',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'IMAGE'        : {
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    11 : 'u_vector.x', 21 : 'u_vector.y', 31 : 'u_vector.z', 
    12 : 'v_vector.x', 22 : 'v_vector.y', 32 : 'v_vector.z', 
    13 : 'size.x', 23 : 'size.y', 33 : 'size.z', 
    14 : 'clip.x', 24 : 'clip.y', 34 : 'clip.z', 
    70 : 'display', 71 : 'cliptype', 
    90 : 'version',
    280 : 'clipstate', 281 : 'brightness', 282 : 'contrast', 283 : 'fade', 
    340 : 'image', 360 : 'reactor',
    },

'INSERT'    : {
    1 : 'attributes_follow', 2 : 'name',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    41 : 'x_scale', 42 : 'y_scale', 43 : 'z_scale', 
    44 : 'column_spacing', 45 : 'row_spacing', 
    50 : 'rotation_angle', 66 : 'attributes_follow',
    70 : 'column_count', 71 : 'row_count', 
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'LEADER'    : {
    3 : 'style',
    10 : ['new_vertex(data)'], 20 : 'vertex.y', 30 : 'vertex.z', 
    40 : 'height', 41 : 'width',
    71 : 'arrowhead', 72 : 'pathtype', 73 : 'creation', 
    74 : 'hookdir', 75 : 'hookline', 76 : 'numverts', 77 : 'color',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    211 : 'horizon.x', 221 : 'horizon.y', 231 : 'horizon.z', 
    212 : 'offset_ins.x', 222 : 'offset_ins.y', 232 : 'offset_ins.z', 
    213 : 'offset_ann.x', 223 : 'offset_ann.y', 233 : 'offset_ann.z', 
    },

'LINE'        : {
    10 : 'start_point.x', 20 : 'start_point.y', 30 : 'start_point.z', 
    11 : 'end_point.x', 21 : 'end_point.y', 31 : 'end_point.z', 
    39 : 'thickness',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'LWPOLYLINE'    : {
    10 : ['new_vertex(data)'], 20 : 'vertex.y', 30 : 'vertex.z', 
    38 : 'elevation', 39 : 'thickness',
    40 : 'start_width', 41 : 'end_width', 42 : 'bulge', 43 : 'constant_width',
    70 : 'flags', 90 : 'numverts',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },
        
'MLINE'    : {
    10 : 'start_point.x', 20 : 'start_point.y', 30 : 'start_point.z', 
    11 : ['new_vertex(data)'], 21 : 'vertex.y', 31 : 'vertex.z', 
    12 : ['new_seg_dir(data)'], 22 : 'seg_dir.y', 32 : 'seg_dir.z', 
    13 : ['new_miter_dir(data)'], 23 : 'miter_dir.y', 33 : 'miter_dir.z', 
    39 : 'thickness',
    40 : 'scale', 41 : 'elem_param', 42 : 'fill_param',
    70 : 'justification', 71 : 'flags',
    72 : 'numverts', 73 : 'numelems', 74 : 'numparam', 75 : 'numfills',
    340 : 'id',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },
        
'MTEXT'        : {
    1 : 'text', 3: 'more_text', 7 : 'style',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
    40 : 'nominal_height', 41 : 'reference_width', 42: 'width', 43 : 'height', 44 : 'line_spacing',
    50 : 'rotation_angle', 
    71 : 'attachment_point', 72 : 'drawing_direction',  73 : 'spacing_style',    
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'POINT'        : {
    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
    39 : 'thickness', 50 : 'orientation',
    },

'POLYLINE'    : {
    1 : 'verts_follow', 2 : 'name',
    10 : 'elevation.x', 20 : 'elevation.y', 30 : 'elevation.z', 
    39 : 'thickness',
    40 : 'start_width', 41 : 'end_width', 
    66 : 'verts_follow_flag',
    70 : 'flags', 71 : 'row_count', 72 : 'column_count', 
    73 : 'row_density', 74 : 'column_density', 75 : 'linetype',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'RAY'        : {
    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
    11 : 'direction.x', 21 : 'direction.y', 31 : 'direction.z', 
    },

'RTEXT'        : {
    1 : 'text', 7 : 'style',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    39 : 'thickness',
    40 : 'height', 
    50 : 'rotation_angle',
    70 : 'flags',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'SHAPE'        : {
    2 : 'name', 
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    39 : 'thickness',
    40 : 'size', 41 : 'x_scale', 
    50 : 'rotation_angle', 51 : 'oblique_angle',     
    39 : 'thickness',
    },

'SOLID'        : {
    10 : 'point0.x', 20 : 'point0.y', 30 : 'point0.z', 
    11 : 'point1.x', 21 : 'point1.y', 31 : 'point1.z', 
    12 : 'point2.x', 22 : 'point2.y', 32 : 'point2.z', 
    13 : 'point3.x', 23 : 'point3.y', 33 : 'point3.z', 
    39 : 'thickness',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'SPLINE'    : {
    10 : ['new_control_point(data)'], 20 : 'control_point.y', 30 : 'control_point.z', 
    11 : ['new_fit_point(data)'], 21 : 'fit_point.y', 31 : 'fit_point.z', 
    40 : ['new_knot_value(data)'], 
    12 : 'start_tangent.x', 22 : 'start_tangent.y', 32 : 'start_tangent.z', 
    13 : 'end_tangent.x', 23 : 'end_tangent.y', 33 : 'end_tangent.z', 
    39 : 'thickness',
    41 : 'weight', 42 : 'knot_tol', 43 : 'control_point_tol', 44 : 'fit_tol',
    70 : 'flag', 71 : 'degree', 
    72 : 'num_knots', 73 : 'num_control_points', 74 : 'num_fit_points',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'TEXT'        : {
    1 : 'text', 7 : 'style',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    11 : 'alignment_point.x', 21 : 'alignment_point.y', 31 : 'alignment_point.z', 
    40 : 'height', 41 : 'x_scale', 
    50 : 'rotation_angle', 51 : 'oblique_angle', 
    71 : 'flags', 72 : 'horizontal_justification',  73 : 'vertical_justification',    
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'TOLERANCE'    : {
    3 : 'style',
    10 : 'insertion_point.x', 20 : 'insertion_point.y', 30 : 'insertion_point.z', 
    11 : 'direction.x', 21 : 'direction.y', 31 : 'direction.z', 
    },

'TRACE'        : {
    10 : 'point0.x', 20 : 'point0.y', 30 : 'point0.z', 
    11 : 'point1.x', 21 : 'point1.y', 31 : 'point1.z', 
    12 : 'point2.x', 22 : 'point2.y', 32 : 'point2.z', 
    13 : 'point3.x', 23 : 'point3.y', 33 : 'point3.z', 
    39 : 'thickness',
    210 : 'normal.x', 220 : 'normal.y', 230 : 'normal.z', 
    },

'VERTEX'    : {
    10 : 'location.x', 20 : 'location.y', 30 : 'location.z', 
    40 : 'start_width', 41 : 'end_width', 42 : 'bulge', 
    50 : 'tangent',
    70 : 'flags',
    71 : 'index1', 72 : 'index2', 73 : 'index3', 74 : 'index4', 
    },

'VIEWPORT'    : {
    10 : 'center.x', 20 : 'center.y', 30 : 'center.z', 
    12 : 'view_center.x', 22 : 'view_center.y', 32 : 'view_center.z', 
    13 : 'snap_base.x', 23 : 'snap_base.y', 33 : 'snap_base.z', 
    14 : 'snap_spacing.x', 24 : 'snap_spacing.y', 34 : 'snap_spacing.z', 
    15 : 'grid_spacing.x', 25 : 'grid_spacing.y', 35 : 'grid_spacing.z', 
    16 : 'view_direction.x', 26 : 'view_direction.y', 36 : 'view_direction.z', 
    40 : 'width', 41 : 'height',
    68 : 'status', 69 : 'id',
    },

'WIPEOUT'    : {
    10 : 'point.x', 20 : 'point.y', 30 : 'point.z', 
    11 : 'direction.x', 21 : 'direction.y', 31 : 'direction.z', 
    },

}


#
#    Flags
#

# Polyline flags
PL_CLOSED         = 0x01
PL_CURVE_FIT_VERTS    = 0x02
PL_SPLINE_FIT_VERTS    = 0x04
PL_3D_POLYLINE        = 0x08
PL_3D_POLYGON_MESH    = 0x10
PL_CLOSED_IN_N_DIR    = 0x20
PL_POLYFACE_MESH    = 0x40
PL_CONTINUOUS        = 0x80


# Vertex flags
VX_EXTRA_FLAG_CREATED        = 0x01
VX_CURVE_FIT_TANGENT_DEFINED    = 0x02
VX_SPLINE_VERTEX_CREATED    = 0x08
VX_SPLINE_FRAME_CONTROL_POINT    = 0x10
VX_3D_POLYLINE_VERTEX        = 0x20
VX_3D_POLYGON_MESH_VERTEX    = 0x40
VX_POLYFACE_MESH_VERTEX        = 0x80

# 3DFACE flags

F3D_EDGE0_INVISIBLE = 0x01
F3D_EDGE1_INVISIBLE = 0x02
F3D_EDGE2_INVISIBLE = 0x04
F3D_EDGE3_INVISIBLE = 0x08

#
#    readDxfFile(filePath):
#

def readDxfFile(fileName):    
    global toggle, theCodec

    print( "Opening DXF file "+ fileName )

    # fp= open(fileName, "rU")
    fp = codecs.open(fileName, "r", encoding=theCodec)
    first = True
    statements = []
    no = 0
    for line in fp: 
        word = line.strip()
        no += 1
        if first:
            if word:
                code = int(word)
                first = False
        else:
            if toggle & T_Verbose:
                print("%4d: %4d %s" % (no, code, word))
            if code < 10:
                data = word
            elif code < 60:
                data = float(word)
            elif code < 100:
                data = int(word)
            elif code < 140:
                data = word
            elif code < 150:
                data = float(word)
            elif code < 200:
                data = int(word)
            elif code < 300:
                data = float(word)
            elif code < 370:
                data = word
            elif code < 390:
                data = int(word)
            elif code < 400:
                data = word
            elif code < 410:
                data = int(word)
            elif code < 1010:
                data = word
            elif code < 1060:
                data = float(word)
            elif code < 1080:
                data = int(word)

            statements.append((code,data))
            first = True
    fp.close()

    statements.reverse()
    sections = {}
    handles = {}
    while statements:
        (code,data) = statements.pop()
        if code == 0:
            if data == 'SECTION':
                section = CSection()
        elif code == 2:
            section.type = data
            if data == 'HEADER':
                parseHeader(section, statements, handles)
                known = False
            elif data == 'CLASSES':
                parseClasses(section, statements, handles)
                known = False
            elif data == 'TABLES':
                parseTables(section, statements, handles)
                known = False
            elif data == 'BLOCKS':
                parseBlocks(section, statements, handles)
                known = False
            elif data == 'ENTITIES':
                parseEntities(section, statements, handles)
                known = False
            elif data == 'OBJECTS':
                parseObjects(section, statements, handles)
            sections[data] = section
        elif code == 999:
            pass
        else:
            raise NameError("Unexpected code in SECTION context: %d %s" % (code,data))

    if toggle & T_Verbose:
        for (typ,section) in sections.items():
            section.display()
    return sections
    

#
#     0
#    SECTION
#      2
#    HEADER
#    
#      9
#    $<variable>
#    <group code>
#    <value>
#    
#      0
#    ENDSEC

    
def parseHeader(section, statements, handles):
    while statements:
        (code,data) = statements.pop()
        if code == 0:
            if data == 'ENDSEC':
                return

    return


#      0
#    SECTION
#      2
#    CLASSES
#    
#      0
#    CLASS
#      1
#    <class dxf record>
#      2
#    <class name>
#      3
#    <app name>
#    90
#    <flag>
#    280
#    <flag>
#    281
#    <flag>
#    
#      0
#    ENDSEC         

def parseClasses(section, statements, handles):
    while statements:
        (code,data) = statements.pop()
        if code == 0:
            if data == 'ENDSEC':
                return

    return
    

#      0
#    SECTION
#      2
#    TABLES
#    
#      0
#    TABLE
#      2
#    <table type>
#      5
#    <handle>
#    100
#    AcDbSymbolTable
#    70
#    <max. entries>
#    
#      0
#    <table type>
#      5
#    <handle>
#    100
#    AcDbSymbolTableRecord
#    .
#    . <data>
#    .
#    
#      0
#    ENDTAB
#    
#      0
#    ENDSEC 

#
#      APPID (application identification table)
#
#      BLOCK_RECORD (block reference table)
#
#      DIMSTYLE (dimension style table)
#
#      LAYER (layer table)
#
#      LTYPE (linetype table)
#
#      STYLE (text style table)
#
#      UCS (User Coordinate System table)
#
#      VIEW (view table)
#
#      VPORT (viewport configuration table)


def parseTables(section, statements, handles):
    tables = []
    section.data = tables
    while statements:
        (code,data) = statements.pop()
        if code == 0:
            if data == 'ENDSEC':
                return
    '''
                known = False
            elif data == 'TABLE':
                table = CTable()
                tables.append(table)
                known = False
            elif data == 'ENDTAB':
                pass
                known = False
            elif data == table.type:
                parseTableType
                table = CTable()
                tables.append(table)
                table.type = word
        elif code == 2:
            table.type = word
        elif code == 5:
            table.handle = word
            handles[word] = table
        elif code == 330:
            table.owner = word
        elif code == 100:
            table.subclass = word
        elif code == 70:
            table.nEntries = int(word)
    '''
    return
    
#      0
#    SECTION
#      2
#    BLOCKS
#    
#      0
#    BLOCK
#      5
#    <handle>
#    100
#    AcDbEntity
#      8
#    <layer>
#    100
#    AcDbBlockBegin
#      2
#    <block name>
#    70
#    <flag>
#    10
#    <X value>
#    20
#    <Y value>
#    30
#    <Z value>
#      3
#    <block name>
#      1
#    <xref path>
#    
#      0
#    <entity type>
#    .
#    . <data>
#    .
#    
#      0
#    ENDBLK
#      5
#    <handle>
#    100
#    AcDbBlockEnd
#    
#      0
#    ENDSEC 

def parseBlocks(section, statements, handles):
    while statements:
        (code,data) = statements.pop()
        if code == 0:
            if data == 'ENDSEC':
                return

    return

#      0
#    SECTION
#      2
#    ENTITIES
#    
#      0
#    <entity type>
#      5
#    <handle>
#    330
#    <pointer to owner>
#    100
#    AcDbEntity
#      8
#    <layer>
#    100
#    AcDb<classname>
#    .
#    . <data>
#    .
#    
#      0
#    ENDSEC

Ignorables = ['DIMENSION', 'TEXT', 'VIEWPORT']

ClassCreators = {
    '3DFACE':         'C3dFace()', 
    '3DSOLID':        'C3dSolid()',
    'ACAD_PROXY_ENTITY':    'CAcadProxyEntity()',
    'ACAD_ZOMBIE_ENTITY':    0,
    'ARC':            'CArc()',
    'ARCALIGNEDTEXT':    'CArcAlignedText()',
    'ATTDEF':        'CAttdef()',
    'ATTRIB':        'CAttrib()',
    'BODY':            0,
    'CIRCLE':        'CCircle()',
    'DIMENSION':        'CDimension()',
    'ELLIPSE':        'CEllipse()',
    'HATCH':        'CHatch()',
    'IMAGE':        'CImage()',
    'INSERT':        'CInsert()',
    'LEADER':        'CLeader()',
    'LINE':            'CLine()',
    'LWPOLYLINE':        'CLWPolyLine()',
    'MLINE':        'CMLine()',
    'MTEXT':        'CMText()',
    'OLEFRAME':        0,
    'OLE2FRAME':        0,
    'POINT':        'CPoint()',
    'POLYLINE':        'CPolyLine()',
    'RAY':            'CRay()',
    'REGION':        0,
    'RTEXT':        'CRText',
    'SEQEND':        0,
    'SHAPE':        'CShape()',
    'SOLID':        'CSolid()',
    'SPLINE':        'CSpline()',
    'TEXT':            'CText()',
    'TOLERANCE':        'CTolerance()',
    'TRACE':        'CTrace()',
    'VERTEX':        'CVertex()',
    'VIEWPORT':        'CViewPort()',
    'WIPEOUT':        'CWipeOut()',
    'XLINE':        'CXLine()',
}

def parseEntities(section, statements, handles):
    entities = []
    section.data = entities
    while statements:
        (code,data) = statements.pop()
        if toggle & T_Verbose:
            print("ent", code,data)
        if code == 0:
            known = True
            if data in Ignorables:
                ignore = True
            else:
                ignore = False

            try:
                creator = ClassCreators[data]
            except:
                creator = None
                
            if creator:
                entity = eval(creator)
            elif data == 'ENDSEC':
                return
            else:
                known = False
                
            if data == 'POLYLINE':
                verts = entity.verts
            elif data == 'VERTEX':
                verts.append(entity)
            
            if data == 'SEQEND':
                attributes = []
                known = False
            elif creator == 0:
                ignore = True
            elif known:
                entities.append(entity)
                attributes = DxfEntityAttributes[data]
            else:
                raise NameError("Unknown data %s" % data)

        elif not known:
            pass
        else:
            expr = getAttribute(attributes, code)
            if expr:
                exec(expr)
            else:
                expr = getAttribute(DxfCommonAttributes, code)
                if expr:
                    exec(expr)
                elif code >= 1000 or ignore:
                    pass
                elif toggle & T_Debug:
                    raise NameError("Unknown code %d for %s" % (code, entity.type))
                
    return

def getAttribute(attributes, code):
    try:
        ext = attributes[code]
        if type(ext) == str:
            expr = "entity.%s = data" % ext
        else:
            name = ext[0]
            expr = "entity.%s" % name
    except:
        expr = None
    return expr


#      0
#    SECTION
#      2
#    OBJECTS
#    
#      0
#    DICTIONARY
#      5
#    <handle>
#    100
#    AcDbDictionary
#    
#      3
#    <dictionary name>
#    350
#    <handle of child>
#    
#      0
#    <object type>
#    .
#    . <data>
#    .
#    
#      0
#    ENDSEC 

def parseObjects(data, statements, handles):
    while statements:
        (code,data) = statements.pop()
        if code == 0:
            if data == 'ENDSEC':
                return

    return
            
#
#    buildGeometry(entities):
#    addMesh(name, verts, edges, faces):                            
#

def buildGeometry(entities):
    try: bpy.ops.object.mode_set(mode='OBJECT')
    except: pass
    v_verts = []
    v_vn = 0
    e_verts = []
    e_edges = []
    e_vn = 0
    f_verts = []
    f_edges = []
    f_faces = []
    f_vn = 0
    for ent in entities:
        if ent.drawtype in ('Mesh','Curve'):
            (verts, edges, faces, vn) = ent.build()
            if not toggle & T_DrawOne:
                drawGeometry(verts, edges, faces)
            else:
                if verts:
                    if faces:
                        for i,f in enumerate(faces):
                            #print ('face=', f)
                            faces[i] = tuple(it+f_vn for it in f)
                        for i,e in enumerate(edges):
                            edges[i] = tuple(it+f_vn for it in e)
                        f_verts.extend(verts)
                        f_edges.extend(edges)
                        f_faces.extend(faces)
                        f_vn += len(verts)
                    elif edges:
                        for i,e in enumerate(edges):
                            edges[i] = tuple(it+e_vn for it in e)
                        e_verts.extend(verts)
                        e_edges.extend(edges)
                        e_vn += len(verts)
                    else:
                        v_verts.extend(verts)
                        v_vn += len(verts)
        else:
            ent.draw()
                    
    if toggle & T_DrawOne:
        drawGeometry(f_verts, f_edges, f_faces)
        drawGeometry(e_verts, e_edges)
        drawGeometry(v_verts)



def drawGeometry(verts, edges=[], faces=[]):
    if verts:
        if edges and (toggle & T_Curves):
            print ('draw Curve')
            cu = bpy.data.curves.new('DXFlines', 'CURVE')
            cu.dimensions = '3D'
            buildSplines(cu, verts, edges)
            ob = addObject('DXFlines', cu)
        else:
            #for v in verts: print(v)
            #print ('draw Mesh with %s vertices' %(len(verts)))
            #for e in edges: print(e)
            #print ('draw Mesh with %s edges' %(len(edges)))
            #for f in faces: print(f)
            #print ('draw Mesh with %s faces' %(len(faces)))
            me = bpy.data.meshes.new('DXFmesh')
            me.from_pydata(verts, edges, faces)
            ob = addObject('DXFmesh', me)
            removeDoubles(ob)
    return



def buildSplines(cu, verts, edges):
    if edges:
        point_list = []
        (v0,v1) = edges.pop()
        v1_old = v1
        newPoints = [tuple(verts[v0]),tuple(verts[v1])]
        for (v0,v1) in edges:
            if v0==v1_old:
                newPoints.append(tuple(verts[v1]))
            else:
                #print ('newPoints=', newPoints)
                point_list.append(newPoints)
                newPoints = [tuple(verts[v0]),tuple(verts[v1])]
            v1_old = v1
        point_list.append(newPoints)
        for points in point_list:
            spline = cu.splines.new('POLY')
            #spline = cu.splines.new('BEZIER')
            #spline.use_endpoint_u = True
            #spline.order_u = 2
            #spline.resolution_u = 1
            #spline.bezier_points.add(2)

            spline.points.add(len(points)-1)
            #spline.points.foreach_set('co', points)
            for i,p in enumerate(points):
                spline.points[i].co = (p[0],p[1],p[2],0)
                
        #print ('spline.type=', spline.type)
        #print ('spline number=', len(cu.splines))
    
    
def addObject(name, data):
    ob = bpy.data.objects.new(name, data)
    scn = bpy.context.scene
    scn.objects.link(ob)
    return ob


def removeDoubles(ob):
    global theMergeLimit
    if toggle & T_Merge:
        scn = bpy.context.scene
        scn.objects.active = ob
        bpy.ops.object.mode_set(mode='EDIT')
        bpy.ops.mesh.remove_doubles(limit=theMergeLimit)
        bpy.ops.object.mode_set(mode='OBJECT')



#
#    clearScene(context):
#
    
def clearScene():
    global toggle
    scn = bpy.context.scene
    print("clearScene %s %s" % (toggle & T_NewScene, scn))
    if not toggle & T_NewScene:
        return scn

    for ob in scn.objects:
        if ob.type in ["MESH", "CURVE", "TEXT"]:
            scn.objects.active = ob
            bpy.ops.object.mode_set(mode='OBJECT')
            scn.objects.unlink(ob)
            del ob
    return scn

#
#    readAndBuildDxfFile(filepath):
#

def readAndBuildDxfFile(filepath):
    fileName = os.path.expanduser(filepath)
    if fileName:
        (shortName, ext) = os.path.splitext(fileName)
        #print("filepath: ", filepath)
        #print("fileName: ", fileName)
        #print("shortName: ", shortName)
        if ext.lower() != ".dxf":
            print("Error: Not a dxf file: " + fileName)
            return
        if toggle & T_NewScene:
            clearScene()
            if 0: # how to switch to the new scene?? (migius)
                new_scn = bpy.data.scenes.new(shortName[-20:])
                #new_scn.layers = (1<<20) -1
                new_scn_name = new_scn.name
                bpy.data.screens.scene = new_scn
                #print("newScene: %s" % (new_scn))
        sections = readDxfFile(fileName)
        print("Building geometry")
        buildGeometry(sections['ENTITIES'].data)
        print("Done")
        return
    print("Error: Not a dxf file: " + filepath)
    return

#
#    User interface
#

DEBUG= False
from bpy.props import *

def tripleList(list1):
    list3 = []
    for elt in list1:
        list3.append((elt,elt,elt))
    return list3

class IMPORT_OT_autocad_dxf(bpy.types.Operator):
    '''Import from DXF file format (.dxf)'''
    bl_idname = "import_scene.autocad_dxf"
    bl_description = 'Import from DXF file format (.dxf)'
    bl_label = "Import DXF" +' v.'+ __version__
    bl_space_type = "PROPERTIES"
    bl_region_type = "WINDOW"

    filepath = StringProperty(name="File Path", description="Filepath used for importing the DXF file", maxlen= 1024, default= "", subtype='FILE_PATH')

    new_scene = BoolProperty(name="Replace scene", description="Replace scene", default=toggle&T_NewScene)
    #new_scene = BoolProperty(name="New scene", description="Create new scene", default=toggle&T_NewScene)
    curves = BoolProperty(name="Draw curves", description="Draw entities as curves", default=toggle&T_Curves)
    thic_on = BoolProperty(name="Thic ON", description="Support THICKNESS", default=toggle&T_ThicON)

    merge = BoolProperty(name="Remove doubles", description="Merge coincident vertices", default=toggle&T_Merge)
    mergeLimit = FloatProperty(name="Limit", description="Merge limit", default = theMergeLimit*1e4,min=1.0, soft_min=1.0, max=100.0, soft_max=100.0)

    draw_one = BoolProperty(name="Merge all", description="Draw all into one mesh-object", default=toggle&T_DrawOne)
    circleResolution = IntProperty(name="Circle resolution", description="Circle/Arc are aproximated will this factor", default = theCircleRes,
                min=4, soft_min=4, max=360, soft_max=360)
    codecs = tripleList(['iso-8859-15', 'utf-8', 'ascii'])
    codec = EnumProperty(name="Codec", description="Codec",  items=codecs, default = 'ascii')

    debug = BoolProperty(name="Debug", description="Unknown DXF-codes generate errors", default=toggle&T_Debug)
    verbose = BoolProperty(name="Verbose", description="Print debug info", default=toggle&T_Verbose)

    ##### DRAW #####
    def draw(self, context):
        layout0 = self.layout
        #layout0.enabled = False

        #col = layout0.column_flow(2,align=True)
        layout = layout0.box()
        col = layout.column()
        #col.prop(self, 'KnotType') waits for more knottypes
        #col.label(text="import Parameters")
        #col.prop(self, 'replace')
        col.prop(self, 'new_scene')
        
        row = layout.row(align=True)
        row.prop(self, 'curves')
        row.prop(self, 'circleResolution')

        row = layout.row(align=True)
        row.prop(self, 'merge')
        if self.merge:
            row.prop(self, 'mergeLimit')
 
        row = layout.row(align=True)
        #row.label('na')
        row.prop(self, 'draw_one')
        row.prop(self, 'thic_on')

        col = layout.column()
        col.prop(self, 'codec')
 
        row = layout.row(align=True)
        row.prop(self, 'debug')
        if self.debug:
            row.prop(self, 'verbose')
         
    def execute(self, context):
        global toggle, theMergeLimit, theCodec, theCircleRes
        O_Merge = T_Merge if self.merge else 0
        #O_Replace = T_Replace if self.replace else 0
        O_NewScene = T_NewScene if self.new_scene else 0
        O_Curves = T_Curves if self.curves else 0
        O_ThicON = T_ThicON if self.thic_on else 0
        O_DrawOne = T_DrawOne if self.draw_one else 0
        O_Debug = T_Debug if self.debug else 0
        O_Verbose = T_Verbose if self.verbose else 0

        toggle =  O_Merge | O_DrawOne | O_NewScene | O_Curves | O_ThicON | O_Debug | O_Verbose
        theMergeLimit = self.mergeLimit*1e-4
        theCircleRes = self.circleResolution
        theCodec = self.codec

        readAndBuildDxfFile(self.filepath)
        return {'FINISHED'}

    def invoke(self, context, event):
        wm = context.window_manager
        wm.fileselect_add(self)
        return {'RUNNING_MODAL'}


def menu_func(self, context):
    self.layout.operator(IMPORT_OT_autocad_dxf.bl_idname, text="Autocad (.dxf)")


def register():
    bpy.utils.register_module(__name__)

    bpy.types.INFO_MT_file_import.append(menu_func)

 
def unregister():
    bpy.utils.unregister_module(__name__)

    bpy.types.INFO_MT_file_import.remove(menu_func)


if __name__ == "__main__":
    register()


