#
# Copyright (c) 2002, 2003, 2004, 2005 Art Haas
#
# This file is part of PythonCAD.
#
# PythonCAD 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.
#
# PythonCAD 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 PythonCAD; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#
# code for doing file saves/loads
#

import sys
import xml.dom.minidom
import os

from PythonCAD.Generic import layer
from PythonCAD.Generic import color
from PythonCAD.Generic import linetype
from PythonCAD.Generic import style
from PythonCAD.Generic import point
from PythonCAD.Generic import segment
from PythonCAD.Generic import circle
from PythonCAD.Generic import arc
from PythonCAD.Generic import hcline
from PythonCAD.Generic import vcline
from PythonCAD.Generic import acline
from PythonCAD.Generic import cline
from PythonCAD.Generic import ccircle
from PythonCAD.Generic import units
from PythonCAD.Generic import segjoint
from PythonCAD.Generic import leader
from PythonCAD.Generic import polyline
from PythonCAD.Generic import text
from PythonCAD.Generic import dimension
from PythonCAD.Generic import fileio

def _save_graph_bits(obj, node, doc, map):
    _st = obj.getStyle()
    assert _st in map, "Object %s style %s not in map!" % (str(obj), `_st`)
    _attr = doc.createAttributeNS("image", "style")
    node.setAttributeNodeNS(_attr)
    node.setAttributeNS("image", "style", `map[_st]`)
    _color = obj.getColor()
    if _color != _st.getColor():
        assert _color in map, "Object %s color not in map!" % str(obj)
        _attr = doc.createAttributeNS("image", "color")
        node.setAttributeNodeNS(_attr)
        node.setAttributeNS("image", "color", `map[_color]`)
    _linetype = obj.getLinetype()
    if _linetype != _st.getLinetype():
        assert _linetype in map, "Object %s linetype not in map!" % str(obj)
        _attr = doc.createAttributeNS("image", "linetype")
        node.setAttributeNodeNS(_attr)
        node.setAttributeNS("image", "linetype", `map[_linetype]`)
    _thickness = obj.getThickness()
    _tdiff = _thickness - _st.getThickness()
    if abs(_tdiff) > 1e-10:
        _attr = doc.createAttributeNS("image", "thickness")
        node.setAttributeNodeNS(_attr)
        node.setAttributeNS("image", "thickness", `_thickness`)

def _save_state_bits(obj, node, doc):
    if not obj.isVisible():
        _attr = doc.createAttributeNS("image", "visibility")
        node.setAttributeNodeNS(_attr)
        node.setAttributeNS("image", "visibility", "False")
    if obj.isLocked():
        _attr = doc.createAttributeNS("image", "locked")
        node.setAttributeNodeNS(_attr)
        node.setAttributeNS("image", "locked", "True")
        
def _save_leaders(lyr, node, doc, map):
    _leaders = lyr.getLayerEntities("leader")
    if len(_leaders):
        _leads = doc.createElementNS("image", "image:Leaders")
        node.appendChild(_leads)
        _i = 0
        for _lead in _leaders:
            _p1, _p2, _p3 = _lead.getPoints()
            _i1 = id(_p1)
            _i2 = id(_p2)
            _i3 = id(_p3)
            assert _i1 in map, "Leader %s p1 not in map!" % str(_lead)
            assert _i2 in map, "Leader %s p2 not in map!" % str(_lead)
            assert _i3 in map, "Leader %s p3 not in map!" % str(_lead)
            _child = doc.createElementNS("image", "image:Leader")
            _leads.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "p1")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p1", `map[_i1]`)
            _attr = doc.createAttributeNS("image", "p2")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p2", `map[_i2]`)
            _attr = doc.createAttributeNS("image", "p3")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p3", `map[_i3]`)
            _attr = doc.createAttributeNS("image", "size")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "size", `_lead.getArrowSize()`)
            _save_graph_bits(_lead, _child, doc, map)
            _save_state_bits(_lead, _child, doc)
            _i = _i + 1

def _save_polylines(lyr, node, doc, map):
    _polylines = lyr.getLayerEntities("polyline")
    if len(_polylines):
        _polys = doc.createElementNS("image", "image:Polylines")
        node.appendChild(_polys)
        _i = 0
        for _polyline in _polylines:
            _pts = _polyline.getPoints()
            _mpts = []
            for _pt in _pts:
                _ip = id(_pt)
                assert _ip in map, "Polyline point not in map: " + str(_pt)
                _mpts.append(map[_ip])
            _child = doc.createElementNS("image", "image:Polyline")
            _polys.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "points")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "points", `_mpts`)
            _save_graph_bits(_polyline, _child, doc, map)
            _save_state_bits(_polyline, _child, doc)
            _i = _i + 1

def _save_textblocks(lyr, node, doc, map):
    _textblocks = lyr.getLayerEntities("text")
    if len(_textblocks):
        _tbs = doc.createElementNS("image", "image:TextBlocks")
        node.appendChild(_tbs)
        _i = 0
        for _textblock in _textblocks:
            _x, _y = _textblock.getLocation()
            _text = _textblock.getText()
            _style = _textblock.getTextStyle()
            assert _style in map, "TextBlock textstyle not in map: " + `_style`
            _child = doc.createElementNS("image", "image:TextBlock")
            _tbs.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "x")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "x", `_x`)
            _attr = doc.createAttributeNS("image", "y")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "y", `_y`)
            _attr = doc.createAttributeNS("image", "tsid")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "tsid", `map[_style]`)
            _save_state_bits(_textblock, _child, doc)
            #
            # save any override values as attributes
            #
            _tbfamily = _textblock.getFamily()
            if _tbfamily != _style.getFamily():
                assert _tbfamily in map, "Missing font family in map: " + _tbfamily
                _attr = doc.createAttributeNS("image", "fid")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "fid", `map[_tbfamily]`)
            _weight = _textblock.getWeight()
            if _weight != _style.getWeight():
                _tbweight = text.font_weight_string(_weight)
                _attr = doc.createAttributeNS("image", "weight")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "weight", _tbweight)
            _st = _textblock.getStyle()
            if _st != _style.getStyle():
                _tbstyle = text.font_style_string(_st)
                _attr = doc.createAttributeNS("image", "style")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "style", _tbstyle)
            _tbsize = _textblock.getSize()
            if _tbsize != _style.getSize():
                _attr = doc.createAttributeNS("image", "size")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "size", `_tbsize`)
            _tbcolor = _textblock.getColor()
            if _tbcolor != _style.getColor():
                assert _tbcolor in map, "Missing font color in map: " + str(_tbcolor)
                _attr = doc.createAttributeNS("image", "cid")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "cid", `map[_tbcolor]`)
            _tbangle = _textblock.getAngle()
            if abs(_tbangle - _style.getAngle()) > 1e-10:
                _attr = doc.createAttributeNS("image", "angle")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "angle", `_tbangle`)
            _tbalign = _textblock.getAlignment()
            if _tbalign != _style.getAlignment():
                _attr = doc.createAttributeNS("image", "halign")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "halign", `_tbalign`)
            #
            # the following is a workaround for the odd way
            # minidom prints text nodes and also the easiest
            # way I see right now to store multiline text ...
            #
            if sys.platform == 'mac':
                _sep = '\r'
            else:
                _sep = '\n'
            _lines = _text.split(_sep)
            for _line in _lines:
                _textline = doc.createElementNS("image", "image:TextLine")
                _child.appendChild(_textline)
                _attr = doc.createAttributeNS("image", "text")
                _textline.setAttributeNodeNS(_attr)
                _textline.setAttributeNS("image", "text", _line)
                #
                # I'd really rather not use an attribute to store
                # the text - using a TextNode would be better so
                # the file would look like the following:
                #
                # ...
                # <image:TextLine>blah blah blah</image:TextLine>
                # <image:TextLine>foo bar blah</image:TextLine>
                # ...
                #
                # minidom adds in newlines and spaces though
                # is there a known workaround or a magic call to
                # have it not do this?
                #
                # _textnode = doc.createTextNode(_line)
                # _textline.appendChild(_textnode)
            _i = _i + 1

def _save_chamfers(lyr, node, doc, map):
    _chamferlist = lyr.getLayerEntities("chamfer")
    if len(_chamferlist):
        _chs = doc.createElementNS("image", "image:Chamfers")
        node.appendChild(_chs)
        _i = 0
        for _ch in _chamferlist:
            _s1, _s2 = _ch.getSegments()
            _i1 = id(_s1)
            _i2 = id(_s2)
            assert _i1 in map, "Chamfer %s seg1 not in map!" % `_ch`
            assert _i2 in map, "Chamfer %s seg2 not in map!" % `_ch`
            _child = doc.createElementNS("image", "image:Chamfer")
            _chs.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "s1")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "s1", `map[_i1]`)
            _attr = doc.createAttributeNS("image", "s2")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "s2", `map[_i2]`)
            _attr = doc.createAttributeNS("image", "length")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "length", `_ch.getLength()`)
            _save_graph_bits(_ch, _child, doc, map)
            _save_state_bits(_ch, _child, doc)
            _i = _i + 1

def _save_fillets(lyr, node, doc, map):
    _filletlist = lyr.getLayerEntities("fillet")
    if len(_filletlist):
        _flts = doc.createElementNS("image", "image:Fillets")
        node.appendChild(_flts)
        _i = 0
        for _flt in _filletlist:
            _s1, _s2 = _flt.getSegments()
            _i1 = id(_s1)
            _i2 = id(_s2)
            assert _i1 in map, "Fillet %s seg1 not in map!" % `_flt`
            assert _i2 in map, "Fillet %s seg2 not in map!" % `_flt`
            _child = doc.createElementNS("image", "image:Fillet")
            _flts.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "_s1")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "s1", `map[_i1]`)
            _attr = doc.createAttributeNS("image", "s2")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "s2", `map[_i2]`)
            _attr = doc.createAttributeNS("image", "radius")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "radius", `_flt.getRadius()`)
            _save_graph_bits(_flt, _child, doc, map)
            _save_state_bits(_flt, _child, doc)
            _i = _i + 1

def _save_dim_override(node, doc, map, stkey, value):
    _child = doc.createElementNS("image", "image:DimOption")
    node.appendChild(_child)
    _attr = doc.createAttributeNS("image", "opt")
    _child.setAttributeNodeNS(_attr)
    _child.setAttributeNS("image", "opt", stkey)
    if (stkey == 'DIM_COLOR' or
        stkey == 'DIM_PRIMARY_FONT_COLOR' or
        stkey == 'DIM_SECONDARY_FONT_COLOR'):
        _attr = doc.createAttributeNS("image", "cid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "cid", `map[value]`)
    elif (stkey == 'DIM_PRIMARY_FONT_FAMILY' or
          stkey == 'DIM_SECONDARY_FONT_FAMILY'):
        _attr = doc.createAttributeNS("image", "fid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "fid", `map[value]`)
    else:
        _attr = doc.createAttributeNS("image", "val")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "val", str(value))

def _save_dim_common(dim, node, doc, map):
    _ds = dim.getDimStyle()
    _offset = dim.getOffset()
    if abs(_ds.getValue('DIM_OFFSET') - _offset) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_OFFSET', _offset)
    _ext = dim.getExtension()
    if abs(_ds.getValue('DIM_EXTENSION') - _ext) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_EXTENSION', _ext)
    _endpt = dim.getEndpointType()
    if _ds.getValue('DIM_ENDPOINT') != _endpt:
        _save_dim_override(node, doc, map, 'DIM_ENDPOINT', _endpt)
    _size = dim.getEndpointSize()
    if abs(_ds.getValue('DIM_ENDPOINT_SIZE') - _size) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_ENDPOINT_SIZE', _size)
    _color = dim.getColor()
    if _ds.getValue('DIM_COLOR') != _color:
        _save_dim_override(node, doc, map, 'DIM_COLOR', _color)
    _dual_mode = dim.getDualDimMode()
    if _ds.getValue('DIM_DUAL_MODE') != _dual_mode:
        _save_dim_override(node, doc, map, 'DIM_DUAL_MODE', _dual_mode)
    _poff = dim.getPositionOffset()
    if abs(_ds.getValue('DIM_POSITION_OFFSET') - _poff) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_POSITION_OFFSET', _poff)
    _dmo = dim.getDualModeOffset()
    if abs(_ds.getValue('DIM_DUAL_MODE_OFFSET') - _dmo) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_DUAL_MODE_OFFSET', _dmo)
    _t = dim.getThickness()
    if abs(_ds.getValue('DIM_THICKNESS') - _t) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_THICKNESS', _ext)
    #
    # primary dimension string
    #
    _pds = dim.getPrimaryDimstring()
    _prefix = _pds.getPrefix()
    if isinstance(dim, dimension.LinearDimension):
        if _ds.getValue('DIM_PRIMARY_PREFIX') != _prefix:
            _save_dim_override(node, doc, map,
                               'DIM_PRIMARY_PREFIX', _prefix)
    elif isinstance(dim, dimension.RadialDimension):
        if _ds.getValue('RADIAL_DIM_PRIMARY_PREFIX') != _prefix:
            _save_dim_override(node, doc, map,
                               'RADIAL_DIM_PRIMARY_PREFIX', _prefix)
    elif isinstance(dim, dimension.AngularDimension):
        if _ds.getValue('ANGULAR_DIM_PRIMARY_PREFIX') != _prefix:
            _save_dim_override(node, doc, map,
                               'ANGULAR_DIM_PRIMARY_PREFIX', _prefix)
    else:
        raise TypeError, "Unexpected dimension type: " + `dim`
    _suffix = _pds.getSuffix()
    if isinstance(dim, dimension.LinearDimension):
        if _ds.getValue('DIM_PRIMARY_SUFFIX') != _suffix:
            _save_dim_override(node, doc, map,
                               'DIM_PRIMARY_SUFFIX', _suffix)
    elif isinstance(dim, dimension.RadialDimension):
        if _ds.getValue('RADIAL_DIM_PRIMARY_SUFFIX') != _suffix:
            _save_dim_override(node, doc, map,
                               'RADIAL_DIM_PRIMARY_SUFFIX', _suffix)
    elif isinstance(dim, dimension.AngularDimension):
        if _ds.getValue('ANGULAR_DIM_PRIMARY_SUFFIX') != _suffix:
            _save_dim_override(node, doc, map,
                               'ANGULAR_DIM_PRIMARY_SUFFIX', _prefix)
    else:
        raise TypeError, "Unexpected dimension type: " + `dim`
    _unit = _pds.getUnits()
    if _ds.getValue('DIM_PRIMARY_UNITS') != _unit:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_UNITS', _unit)
    _precision = _pds.getPrecision()
    if _ds.getValue('DIM_PRIMARY_PRECISION') != _precision:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_PRECISION',
                           _precision)
    _print_zero = _pds.getPrintZero()
    if _ds.getValue('DIM_PRIMARY_LEADING_ZERO') != _print_zero:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_LEADING_ZERO',
                           _print_zero)
    _print_dec = _pds.getPrintDecimal()
    if _ds.getValue('DIM_PRIMARY_TRAILING_DECIMAL') != _print_dec:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_TRAILING_DECIMAL',
                           _print_dec)
    _family = _pds.getFamily()
    if _ds.getValue('DIM_PRIMARY_FONT_FAMILY') != _family:
        assert _family in map, "Font family %s missing in map" % _family
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_FONT_FAMILY', _family)
    _size = _pds.getSize()
    if _ds.getValue('DIM_PRIMARY_FONT_SIZE') != _size:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_FONT_SIZE', _size)
    _font_style = _pds.getStyle()
    if _ds.getValue('DIM_PRIMARY_FONT_STYLE') != _font_style:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_FONT_STYLE',
                           _font_style)
    _weight = _pds.getWeight()
    if _ds.getValue('DIM_PRIMARY_FONT_WEIGHT') != _weight:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_FONT_WEIGHT', _weight)
    _font_color = _pds.getColor()
    if _ds.getValue('DIM_PRIMARY_FONT_COLOR') != _font_color:
        assert _font_color in map, "Font color missing in map: " + `_font_color`
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_FONT_COLOR',
                           _font_color)
    _size = _pds.getSize()
    if abs(_ds.getValue('DIM_PRIMARY_TEXT_SIZE') - _size) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_TEXT_SIZE', _size)
    _angle = _pds.getAngle()
    if abs(_ds.getValue('DIM_PRIMARY_TEXT_ANGLE') - _angle) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_TEXT_ANGLE', _angle)
    _align = _pds.getAlignment()
    if _ds.getValue('DIM_PRIMARY_TEXT_ALIGNMENT') != _align:
        _save_dim_override(node, doc, map, 'DIM_PRIMARY_TEXT_ALIGN', _align)
    #
    # secondary dimension string
    #
    _sds = dim.getSecondaryDimstring()
    _prefix = _sds.getPrefix()
    if isinstance(dim, dimension.LinearDimension):
        if _ds.getValue('DIM_SECONDARY_PREFIX') != _prefix:
            _save_dim_override(node, doc, map,
                               'DIM_SECONDARY_PREFIX', _prefix)
    elif isinstance(dim, dimension.RadialDimension):
        if _ds.getValue('RADIAL_DIM_SECONDARY_PREFIX') != _prefix:
            _save_dim_override(node, doc, map,
                               'RADIAL_DIM_SECONDARY_PREFIX', _prefix)
    elif isinstance(dim, dimension.AngularDimension):
        if _ds.getValue('ANGULAR_DIM_SECONDARY_PREFIX') != _prefix:
            _save_dim_override(node, doc, map,
                               'ANGULAR_DIM_SECONDARY_PREFIX', _prefix)
    else:
        raise TypeError, "Unexpected dimension type: " + `dim`
    _suffix = _sds.getSuffix()
    if isinstance(dim, dimension.LinearDimension):
        if _ds.getValue('DIM_SECONDARY_SUFFIX') != _suffix:
            _save_dim_override(node, doc, map,
                               'DIM_SECONDARY_SUFFIX', _suffix)
    elif isinstance(dim, dimension.RadialDimension):
        if _ds.getValue('RADIAL_DIM_SECONDARY_SUFFIX') != _suffix:
            _save_dim_override(node, doc, map,
                               'RADIAL_DIM_SECONDARY_SUFFIX', _suffix)
    elif isinstance(dim, dimension.AngularDimension):
        if _ds.getValue('ANGULAR_DIM_SECONDARY_SUFFIX') != _suffix:
            _save_dim_override(node, doc, map,
                               'ANGULAR_DIM_SECONDARY_SUFFIX', _prefix)
    else:
        raise TypeError, "Unexpected dimension type: " + `dim`
    _unit = _sds.getUnits()
    if _ds.getValue('DIM_SECONDARY_UNITS') != _unit:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_UNITS', _unit)
    _precision = _sds.getPrecision()
    if _ds.getValue('DIM_SECONDARY_PRECISION') != _precision:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_PRECISION',
                           _precision)
    _print_zero = _sds.getPrintZero()
    if _ds.getValue('DIM_SECONDARY_LEADING_ZERO') != _print_zero:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_LEADING_ZERO',
                           _print_zero)
    _print_dec = _sds.getPrintDecimal()
    if _ds.getValue('DIM_SECONDARY_TRAILING_DECIMAL') != _print_dec:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_TRAILING_DECIMAL',
                           _print_dec)
    _family = _sds.getFamily()
    if _ds.getValue('DIM_SECONDARY_FONT_FAMILY') != _family:
        assert _family in map, "Font family %s missing in map" % _family
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_FONT_FAMILY', _family)
    _size = _sds.getSize()
    if _ds.getValue('DIM_SECONDARY_FONT_SIZE') != _size:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_FONT_SIZE', _size)
    _font_style = _sds.getStyle()
    if _ds.getValue('DIM_SECONDARY_FONT_STYLE') != _font_style:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_FONT_STYLE',
                           _font_style)
    _weight = _sds.getWeight()
    if _ds.getValue('DIM_SECONDARY_FONT_WEIGHT') != _weight:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_FONT_WEIGHT', _weight)
    _font_color = _sds.getColor()
    if _ds.getValue('DIM_SECONDARY_FONT_COLOR') != _font_color:
        assert _font_color in map, "Font color missing in map: " + `_font_color`
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_FONT_COLOR',
                           _font_color)
    _size = _pds.getSize()
    if abs(_ds.getValue('DIM_SECONDARY_TEXT_SIZE') - _size) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_TEXT_SIZE', _size)
    _angle = _pds.getAngle()
    if abs(_ds.getValue('DIM_SECONDARY_TEXT_ANGLE') - _angle) > 1e-10:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_TEXT_ANGLE', _angle)
    _align = _pds.getAlignment()
    if _ds.getValue('DIM_SECONDARY_TEXT_ALIGNMENT') != _align:
        _save_dim_override(node, doc, map, 'DIM_SECONDARY_TEXT_ALIGN', _align)

def _save_linear_dims(l, node, doc, map, entmap, dimtype):
    if dimtype == 'linear_dimension':
        _tag = 'image:LDims'
    elif dimtype == 'horizontal_dimension':
        _tag = 'image:HDims'
    elif dimtype == 'vertical_dimension':
        _tag = 'image:VDims'
    else:
        raise ValueError, "Unexpected linear dimension type: " + `dimtype`
    _ldimlist = l.getLayerEntities(dimtype)
    if len(_ldimlist):
        _item_tag = _tag[:-1]
        _block = doc.createElementNS("image", _tag)
        node.appendChild(_block)
        _i = 0
        for _dim in _ldimlist:
            _p1, _p2 = _dim.getDimPoints()
            _l1, _l2 = _dim.getDimLayers()
            _x, _y = _dim.getLocation()
            _ds = _dim.getDimStyle()
            _child = doc.createElementNS("image", _item_tag)
            _block.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "l1")
            _child.setAttributeNodeNS(_attr)
            _il = id(_l1)
            if _il in map:
                _child.setAttributeNS("image", "l1", `map[_il]`)
            else:
                entmap.saveEntity(_child, 'l1', _l1)
            _attr = doc.createAttributeNS("image", "p1")
            _child.setAttributeNodeNS(_attr)
            _ip = id(_p1)
            if _ip in map:
                _child.setAttributeNS("image", "p1", `map[_ip]`)
            else:
                entmap.saveEntity(_child, 'p1', _p1)
            _attr = doc.createAttributeNS("image", "l2")
            _child.setAttributeNodeNS(_attr)
            _il = id(_l2)
            if _il in map:
                _child.setAttributeNS("image", "l2", `map[_il]`)
            else:
                entmap.saveEntity(_child, 'l2', _l2)
            _attr = doc.createAttributeNS("image", "p2")
            _child.setAttributeNodeNS(_attr)
            _ip = id(_p2)
            if _ip in map:
                _child.setAttributeNS("image", "p2", `map[_ip]`)
            else:
                entmap.saveEntity(_child, 'p2', _p2)
            _attr = doc.createAttributeNS("image", "x")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "x", `_x`)
            _attr = doc.createAttributeNS("image", "y")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "y", `_y`)
            _attr = doc.createAttributeNS("image", "ds")
            assert _ds in map, "Missing DimStyle in map: " + `_ds`
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "ds", `map[_ds]`)
            _save_dim_common(_dim, _child, doc, map)
            _save_state_bits(_dim, _child, doc)

def _save_radial_dims(lyr, node, doc, map, entmap):
    _rdimlist = lyr.getLayerEntities("radial_dimension")
    if len(_rdimlist):
        _rdims = doc.createElementNS("image", "image:RDims")
        node.appendChild(_rdims)
        _i = 0
        for _rdim in _rdimlist:
            _dl = _rdim.getDimLayer()
            _dc = _rdim.getDimCircle()
            _x, _y = _rdim.getLocation()
            _ds = _rdim.getDimStyle()
            _child = doc.createElementNS("image", "image:RDim")
            _rdims.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "l")
            _child.setAttributeNodeNS(_attr)
            _il = id(_dl)
            if _il in map:
                _child.setAttributeNS("image", "l", `map[_il]`)
            else:
                entmap.saveEntity(_child, 'l', _dl)
            _attr = doc.createAttributeNS("image", "c")
            _child.setAttributeNodeNS(_attr)
            _ic = id(_dc)
            if _ic in map:
                _child.setAttributeNS("image", "c", `map[_ic]`)
            else:
                entmap.saveEntity(_child, 'c', _dc)
            _attr = doc.createAttributeNS("image", "x")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "x", `_x`)
            _attr = doc.createAttributeNS("image", "y")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "y", `_y`)
            _attr = doc.createAttributeNS("image", "ds")
            assert _ds in map, "Missing DimStyle in map: " + `_ds`
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "ds", `map[_ds]`)
            _save_dim_common(_rdim, _child, doc, map)
            _save_state_bits(_rdim, _child, doc)
            _dia_mode = _rdim.getDiaMode()
            if _ds.getValue('RADIAL_DIM_DIA_MODE') != _dia_mode:
                _opt = doc.createElementNS("image", "image:DimOption")
                _child.appendChild(_opt)
                _attr = doc.createAttributeNS("image", "opt")
                _opt.setAttributeNodeNS(_attr)
                _opt.setAttributeNS("image", "opt", 'RADIAL_DIM_DIA_MODE')
                _attr = doc.createAttributeNS("image", "val")
                _opt.setAttributeNodeNS(_attr)
                _opt.setAttributeNS("image", "val", `_dia_mode`)

def _save_angular_dims(lyr, node, doc, map, entmap):
    _adimlist = lyr.getLayerEntities("angular_dimension")
    if len(_adimlist):
        _adims = doc.createElementNS("image", "image:ADims")
        node.appendChild(_adims)
        _i = 0
        for _adim in _adimlist:
            _p1, _p2, _p3 = _adim.getDimPoints()
            _l1, _l2, _l3 = _adim.getDimLayers()
            _x, _y = _adim.getLocation()
            _ds = _adim.getDimStyle()
            _child = doc.createElementNS("image", "image:ADim")
            _adims.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "l1")
            _child.setAttributeNodeNS(_attr)
            _il = id(_l1)
            if _il in map:
                _child.setAttributeNS("image", "l1", `map[_il]`)
            else:
                entmap.saveEntity(_child, 'l1', _l1)
            _attr = doc.createAttributeNS("image", "p1")
            _child.setAttributeNodeNS(_attr)
            _ip = id(_p1)
            if _ip in map:
                _child.setAttributeNS("image", "p1", `map[_ip]`)
            else:
                entmap.saveEntity(_child, 'p1', _p1)
            _attr = doc.createAttributeNS("image", "l2")
            _child.setAttributeNodeNS(_attr)
            _il = id(_l2)
            if _il in map:
                _child.setAttributeNS("image", "l2", `map[_il]`)
            else:
                entmap.saveEntity(_child, 'l2', _l2)
            _attr = doc.createAttributeNS("image", "p2")
            _child.setAttributeNodeNS(_attr)
            _ip = id(_p2)
            if _ip in map:
                _child.setAttributeNS("image", "p2", `map[_ip]`)
            else:
                entmap.saveEntity(_child, 'p2', _p2)
            _attr = doc.createAttributeNS("image", "l3")
            _child.setAttributeNodeNS(_attr)
            _il = id(_l3)
            if _il in map:
                _child.setAttributeNS("image", "l3", `map[_il]`)
            else:
                entmap.saveEntity(_child, 'l3', _l3)
            _attr = doc.createAttributeNS("image", "p3")
            _child.setAttributeNodeNS(_attr)
            _ip = id(_p3)
            if _ip in map:
                _child.setAttributeNS("image", "p3", `map[_ip]`)
            else:
                entmap.saveEntity(_child, 'p3', _p3)
            _attr = doc.createAttributeNS("image", "x")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "x", `_x`)
            _attr = doc.createAttributeNS("image", "y")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "y", `_y`)
            _attr = doc.createAttributeNS("image", "ds")
            assert _ds in map, "Missing DimStyle in map: " + `_ds`
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "ds", `map[_ds]`)
            _save_dim_common(_adim, _child, doc, map)
            _save_state_bits(_adim, _child, doc)

def _save_ccircles(lyr, node, doc, map):
    _cclist = lyr.getLayerEntities("ccircle")
    if len(_cclist):
        _ccircs = doc.createElementNS("image", "image:CCircles")
        node.appendChild(_ccircs)
        _i = 0
        for _cc in _cclist:
            _cp = _cc.getCenter()
            _ic = id(_cp)
            assert _ic in map, "CCircle %s center not in map!" % str(_cc)
            _child = doc.createElementNS("image", "image:CCircle")
            _ccircs.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "cp")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "cp", `map[_ic]`)
            _attr = doc.createAttributeNS("image", "r")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "r", `_cc.getRadius()`)
            _save_state_bits(_cc, _child, doc)
            _i = _i + 1

def _save_clines(lyr, node, doc, map):
    _cllist = lyr.getLayerEntities("cline")
    if len(_cllist):
        _clines = doc.createElementNS("image", "image:CLines")
        node.appendChild(_clines)
        _i = 0
        for _cl in _cllist:
            _p1, _p2 = _cl.getKeypoints()
            _i1 = id(_p1)
            _i2 = id(_p2)
            assert _i1 in map, "CLine %s p1 not in map!" % str(_cl)
            assert _i2 in map, "CLine %s p2 not in map!" % str(_cl)
            _child = doc.createElementNS("image", "image:CLine")
            _clines.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "p1")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p1", `map[_i1]`)
            _attr = doc.createAttributeNS("image", "p2")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p2", `map[_i2]`)
            _save_state_bits(_cl, _child, doc)
            _i = _i + 1

def _save_aclines(lyr, node, doc, map):
    _acllist = lyr.getLayerEntities("acline")
    if len(_acllist):
        _acls = doc.createElementNS("image", "image:ACLines")
        node.appendChild(_acls)
        _i = 0
        for _acl in _acllist:
            _loc = _acl.getLocation()
            _il = id(_loc)
            assert _il in map, "ACline %s point not in map!" % str(_acl)
            _child = doc.createElementNS("image", "image:ACLine")
            _acls.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "angle")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "angle", `_acl.getAngle()`)
            _attr = doc.createAttributeNS("image", "location")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "location", `map[_il]`)
            _save_state_bits(_acl, _child, doc)
            _i = _i + 1

def _save_vclines(lyr, node, doc, map):
    _vcllist = lyr.getLayerEntities("vcline")
    if len(_vcllist):
        _vcls = doc.createElementNS("image", "image:VCLines")
        node.appendChild(_vcls)
        _i = 0
        for _vcl in _vcllist:
            _loc = _vcl.getLocation()
            _il = id(_loc)
            assert _il in map, "VCline %s point not in map!" % str(_vcl)
            _child = doc.createElementNS("image", "image:VCLine")
            _vcls.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "location")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "location", `map[_il]`)
            _save_state_bits(_vcl, _child, doc)
            _i = _i + 1

def _save_hclines(lyr, node, doc, map):
    _hcllist = lyr.getLayerEntities("hcline")
    if len(_hcllist):
        _hcls = doc.createElementNS("image", "image:HCLines")
        node.appendChild(_hcls)
        _i = 0
        for _hcl in _hcllist:
            _loc = _hcl.getLocation()
            _il = id(_loc)
            assert _il in map, "HCline %s point not in map!" % str(_hcl)
            _child = doc.createElementNS("image", "image:HCLine")
            _hcls.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "location")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "location", `map[_il]`)
            _save_state_bits(_hcl, _child, doc)
            _i = _i + 1

def _save_arcs(lyr, node, doc, map):
    _arclist = lyr.getLayerEntities("arc")
    if len(_arclist):
        _arcs = doc.createElementNS("image", "image:Arcs")
        node.appendChild(_arcs)
        _i = 0
        for _arc in _arclist:
            _cp = _arc.getCenter()
            _ic = id(_cp)
            assert _ic in map, "Arc %s center not in map!" % str(_arc)
            _child = doc.createElementNS("image", "image:Arc")
            _arcs.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "cp")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "cp", `map[_ic]`)
            _attr = doc.createAttributeNS("image", "r")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "r", `_arc.getRadius()`)
            _attr = doc.createAttributeNS("image", "sa")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "sa", `_arc.getStartAngle()`)
            _attr = doc.createAttributeNS("image", "ea")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "ea", `_arc.getEndAngle()`)
            _save_graph_bits(_arc, _child, doc, map)
            _save_state_bits(_arc, _child, doc)
            if _arc.hasUsers():
                map[id(_arc)] = _i
            _i = _i + 1

def _save_circles(lyr, node, doc, map):
    _circles = lyr.getLayerEntities("circle")
    if len(_circles):
        _circs = doc.createElementNS("image", "image:Circles")
        node.appendChild(_circs)
        _i = 0
        for _circle in _circles:
            _cp = _circle.getCenter()
            _ic = id(_cp)
            assert _ic in map, "Circle %s center not in map!" % str(_circle)
            _child = doc.createElementNS("image", "image:Circle")
            _circs.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "cp")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "cp", `map[_ic]`)
            _attr = doc.createAttributeNS("image", "r")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "r", `_circle.getRadius()`)
            _save_graph_bits(_circle, _child, doc, map)
            _save_state_bits(_circle, _child, doc)
            if _circle.hasUsers():
                map[id(_circle)] = _i
            _i = _i + 1

def _save_segments(lyr, node, doc, map):
    _segments = lyr.getLayerEntities("segment")
    if len(_segments):
        _segs = doc.createElementNS("image", "image:Segments")
        node.appendChild(_segs)
        _i = 0
        for _seg in _segments:
            _p1, _p2 = _seg.getEndpoints()
            _i1 = id(_p1)
            _i2 = id(_p2)
            assert _i1 in map, "Segment %s p1 not in map!" % str(_seg)
            assert _i2 in map, "Segment %s p2 not in map!" % str(_seg)
            _child = doc.createElementNS("image", "image:Segment")
            _segs.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "p1")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p1", `map[_i1]`)
            _attr = doc.createAttributeNS("image", "p2")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "p2", `map[_i2]`)
            _save_graph_bits(_seg, _child, doc, map)
            _save_state_bits(_seg, _child, doc)
            if _seg.hasUsers():
                map[id(_seg)] = _i
            _i = _i + 1

def _save_points(lyr, node, doc, map):
    _points = lyr.getLayerEntities("point")
    if len(_points):
        _pts = doc.createElementNS("image", "image:Points")
        node.appendChild(_pts)
        _i = 0
        for _pt in _points:
            _x, _y = _pt.getCoords()
            _child = doc.createElementNS("image", "image:Point")
            _pts.appendChild(_child)
            _attr = doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = doc.createAttributeNS("image", "x")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "x", `_x`)
            _attr = doc.createAttributeNS("image", "y")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "y", `_y`)
            _save_state_bits(_pt, _child, doc)
            if _pt.hasUsers():
                map[id(_pt)] = _i
            _i = _i + 1

def _make_xml_doc():
    _newdoc = xml.dom.minidom.Document()
    _root = _newdoc.createElementNS("image", "image:Image")
    _newdoc.appendChild(_root)
    _attr = _newdoc.createAttributeNS("xmlns", "xmlns:image")
    _root.setAttributeNodeNS(_attr)
    _root.setAttributeNS("xmlns", "xmlns:image", "http://www.pythoncad.org")
    _attr = _newdoc.createAttributeNS("xmlns", "xmlns:xsi")
    _root.setAttributeNodeNS(_attr)
    _root.setAttributeNS("xmlns", "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
    _attr = _newdoc.createAttributeNS("xsi", "xsi:schemaLocation")
    _root.setAttributeNodeNS(_attr)
    _root.setAttributeNS("xmlns", "xsi:schemaLocation", "http://www.pythoncad.org")
    return _newdoc

def _save_dimstyles(attmap, node, doc, map):
    _dimstyles = doc.createElementNS("image", "image:DimStyles")
    node.appendChild(_dimstyles)
    _dslist = attmap['dimstyles']
    _i = 0
    for _ds in _dslist:
        _child = doc.createElementNS("image", "image:DimStyle")
        _dimstyles.appendChild(_child)
        _attr = doc.createAttributeNS("image", "id")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "id", `_i`)
        _attr = doc.createAttributeNS("image", "name")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "name", _ds.getName())
        _stkeys = _ds.getOptions()
        _stkeys.sort()
        for _stkey in _stkeys:
            _value = _ds.getValue(_stkey)
            _dsfield = doc.createElementNS("image", "image:DimOption")
            _child.appendChild(_dsfield)
            _attr = doc.createAttributeNS("image", "opt")
            _dsfield.setAttributeNodeNS(_attr)
            _dsfield.setAttributeNS("image", "opt", _stkey)
            if (_stkey == 'DIM_COLOR' or
                _stkey == 'DIM_PRIMARY_FONT_COLOR' or
                _stkey == 'DIM_SECONDARY_FONT_COLOR'):
                assert _value in map, "color %s not found in map!" % str(_value)
                _attr = doc.createAttributeNS("image", "cid")
                _dsfield.setAttributeNodeNS(_attr)
                _dsfield.setAttributeNS("image", "cid", `map[_value]`)
            elif (_stkey == 'DIM_PRIMARY_FONT_FAMILY' or
                  _stkey == 'DIM_SECONDARY_FONT_FAMILY'):
                assert _value in map, "font %s not found in map!" % str(_value)
                _attr = doc.createAttributeNS("image", "fid")
                _dsfield.setAttributeNodeNS(_attr)
                _dsfield.setAttributeNS("image", "fid", `map[_value]`)
            elif (_stkey == 'DIM_PRIMARY_PREFIX' or
                  _stkey == 'DIM_PRIMARY_SUFFIX' or
                  _stkey == 'DIM_SECONDARY_PREFIX' or
                  _stkey == 'DIM_SECONDARY_SUFFIX' or
                  _stkey == 'RADIAL_DIM_PRIMARY_PREFIX' or
                  _stkey == 'RADIAL_DIM_PRIMARY_SUFFIX' or
                  _stkey == 'RADIAL_DIM_SECONDARY_PREFIX' or
                  _stkey == 'RADIAL_DIM_SECONDARY_SUFFIX' or
                  _stkey == 'ANGULAR_DIM_PRIMARY_PREFIX' or
                  _stkey == 'ANGULAR_DIM_PRIMARY_SUFFIX' or
                  _stkey == 'ANGULAR_DIM_SECONDARY_PREFIX' or
                  _stkey == 'ANGULAR_DIM_SECONDARY_SUFFIX'):
                _attr = doc.createAttributeNS("image", "val")
                _dsfield.setAttributeNodeNS(_attr)
                _dsfield.setAttributeNS("image", "val", str(_value))
            else:
                _attr = doc.createAttributeNS("image", "val")
                _dsfield.setAttributeNodeNS(_attr)
                _dsfield.setAttributeNS("image", "val", `_value`)
        map[_ds] = _i
        _i = _i + 1

def _save_textstyles(attmap, node, doc, map):
    _textstyles = doc.createElementNS("image", "image:TextStyles")
    node.appendChild(_textstyles)
    _tslist = attmap['textstyles']
    _i = 0
    for _ts in _tslist:
        _child = doc.createElementNS("image", "image:TextStyle")
        _textstyles.appendChild(_child)
        _attr = doc.createAttributeNS("image", "id")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "id", `_i`)
        _attr = doc.createAttributeNS("image", "name")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "name", _ts.getName())
        _family = _ts.getFamily()
        assert _family in map, "Missing font family in map: " + _family
        _attr = doc.createAttributeNS("image", "fid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "fid", `map[_family]`)
        _weight = text.font_weight_string(_ts.getWeight())
        _attr = doc.createAttributeNS("image", "weight")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "weight", _weight)
        _style = text.font_style_string(_ts.getStyle())
        _attr = doc.createAttributeNS("image", "style")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "style", _style)
        _size = _ts.getSize()
        _attr = doc.createAttributeNS("image", "size")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "size", `_size`)
        _angle = _ts.getAngle()
        _attr = doc.createAttributeNS("image", "angle")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "angle", `_angle`)
        _align = _ts.getAlignment()
        _attr = doc.createAttributeNS("image", "halign")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "halign", `_align`)
        _color = _ts.getColor()
        assert _color in map, "Missing font color in map: " + str(_color)
        _attr = doc.createAttributeNS("image", "cid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "cid", `map[_color]`)
        map[_ts] = _i
        _i = _i + 1

def _save_font_families(attmap, node, doc, map):
    _families = doc.createElementNS("image", "image:FontFamilies")
    node.appendChild(_families)
    _i = 0
    _fontlist = attmap['fonts']
    for _font in _fontlist:
        _child = doc.createElementNS("image", "image:FontFamily")
        _families.appendChild(_child)
        _attr = doc.createAttributeNS("image", "id")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "id", `_i`)
        _attr = doc.createAttributeNS("image", "name")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "name", _font)
        map[_font] = _i
        _i = _i + 1

def _save_styles(attmap, node, doc, map):
    _styles = doc.createElementNS("image", "image:Styles")
    node.appendChild(_styles)
    _i = 0
    _stylelist = attmap['styles']
    for _style in _stylelist:
        _child = doc.createElementNS("image", "image:Style")
        _styles.appendChild(_child)
        _attr = doc.createAttributeNS("image", "id")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "id", `_i`)
        _attr = doc.createAttributeNS("image", "name")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "name", _style.getName())
        _color = _style.getColor()
        assert _color in map, "Color not found in map!"
        _attr = doc.createAttributeNS("image", "cid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "cid", `map[_color]`)
        _linetype = _style.getLinetype()
        assert _linetype in map, "Linetype not found in map!"
        _attr = doc.createAttributeNS("image", "ltid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "ltid", `map[_linetype]`)
        _attr = doc.createAttributeNS("image", "thickness")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "thickness", `_style.getThickness()`)
        map[_style] = _i
        _i = _i + 1

def _save_colors(attmap, node, doc, map):
    _colors = doc.createElementNS("image", "image:Colors")
    node.appendChild(_colors)
    _i = 0
    _colorlist = attmap['colors']
    for _color in _colorlist:
        _r, _g, _b = _color.getColors()
        _child = doc.createElementNS("image", "image:Color")
        _colors.appendChild(_child)
        _attr = doc.createAttributeNS("image", "id")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "id", `_i`)
        _attr = doc.createAttributeNS("image", "r")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "r", `_r`)
        _attr = doc.createAttributeNS("image", "g")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "g", `_g`)
        _attr = doc.createAttributeNS("image", "b")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "b", `_b`)
        #
        # save color as hex string as well
        #
        # It may be better to save colors like ...
        #
        # <image:Color>#ffffff</image:Color>
        #
        _attr = doc.createAttributeNS("image", "color")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "color", str(_color))
        map[_color] = _i
        _i = _i + 1

def _save_linetypes(attmap, node, doc, map):
    _linetypes = doc.createElementNS("image", "image:Linetypes")
    node.appendChild(_linetypes)
    _i = 0
    _linetypelist = attmap['linetypes']
    for _linetype in _linetypelist:
        _child = doc.createElementNS("image", "image:Linetype")
        _linetypes.appendChild(_child)
        _attr = doc.createAttributeNS("image", "id")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "id", `_i`)
        _attr = doc.createAttributeNS("image", "name")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "name", _linetype.getName())
        _attr = doc.createAttributeNS("image", "pattern")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "pattern", `_linetype.getList()`)
        map[_linetype] = _i
        _i = _i + 1

def _save_units(image, node, doc):
    _uts = doc.createElementNS("image", "image:Units")
    node.appendChild(_uts)
    _attr = doc.createAttributeNS("image", "unit")
    _uts.setAttributeNodeNS(_attr)
    _ustr = units.unit_string(image.getUnits())
    _uts.setAttributeNS("image", "unit", _ustr)

def _save_globals(attmap, node, doc, map):
#
# for now, assumes globals are ONLY colors
#
    _globals = doc.createElementNS("image", "image:Globals")
    node.appendChild(_globals)
    _globaldict = attmap['globals']
    _keylist = _globaldict.keys()
    for _key in _keylist:
        _child = doc.createElementNS("image", "image:Global")
        _globals.appendChild(_child)
        _attr = doc.createAttributeNS("image", "key")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "key", _key)
        _val = _globaldict[_key]
        assert _val in map, "Color not found in map!"
        _attr = doc.createAttributeNS("image", "cid")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("image", "cid", `map[_val]`)



_entlist = [
    'segment',
    'circle',
    'arc',
    'chamfer',
    'fillet',
    'leader',
    'polyline',
    ]

_conobjs = [
    'hcline',
    'vcline',
    'acline',
    'cline',
    'ccircle',
    ]

_dimlist = [
    'linear_dimension',
    'horizontal_dimension',
    'vertical_dimension',
    'radial_dimension',
    'angular_dimension',
    ]

def _get_image_attributes(image):
    _attmap = {}
    _styles = []
    _attmap['styles'] = _styles
    _colors = []
    _attmap['colors'] = _colors
    _linetypes = []
    _attmap['linetypes'] = _linetypes
    _fonts = []
    _attmap['fonts'] = _fonts
    _dimstyles = []
    _attmap['dimstyles'] = _dimstyles
    _textstyles = []
    _attmap['textstyles'] = _textstyles
    _globals = {}
    _attmap['globals'] = _globals
    #
    # Get global properties
    #
    for _key in ['BACKGROUND_COLOR', 'INACTIVE_LAYER_COLOR', 'SINGLE_POINT_COLOR', 'MULTI_POINT_COLOR']:
        _val = _globals[_key] = image.getOption(_key)
        if _val not in _colors:
            _colors.append(_val)
    _check_conobjs = True
    _layers = [image.getTopLayer()]
    while len(_layers):
        _layer = _layers.pop()
        for _ent in _entlist:
            for _obj in _layer.getLayerEntities(_ent):
                #
                # get style properties
                #
                _style = _obj.getStyle()
                if _style not in _styles:
                    _styles.append(_style)
                _color = _style.getColor() # style color
                if _color not in _colors:
                    _colors.append(_color)
                _linetype = _style.getLinetype() # style linetype
                if _linetype not in _linetypes:
                    _linetypes.append(_linetype)
                #
                # object may have overridden style values
                #
                _color = _obj.getColor()
                if _color not in _colors:
                    _colors.append(_color)
                _linetype = _obj.getLinetype()
                if _linetype not in _linetypes:
                    _linetypes.append(_linetype)
        if _check_conobjs:
            for _conobj in _conobjs:
                for _obj in _layer.getLayerEntities(_conobj):
                    _check_conobjs = False
                    _style = _obj.getStyle()
                    if _style not in _styles:
                        _styles.append(_style)
                    _color = _style.getColor()
                    if _color not in _colors:
                        _colors.append(_color)
                    _linetype = _style.getLinetype()
                    if _linetype not in _linetypes:
                        _linetypes.append(_linetype)
                    break
                if not _check_conobjs:
                    break
        for _dim in _dimlist:
            for _obj in _layer.getLayerEntities(_dim):
                #
                # get style properties
                #
                _ds = _obj.getDimStyle()
                if _ds not in _dimstyles:
                    _dimstyles.append(_ds)
                _color = _ds.getOption('DIM_COLOR')
                if _color not in _colors:
                    _colors.append(_color)
                _color = _ds.getOption('DIM_PRIMARY_FONT_COLOR')
                if _color not in _colors:
                    _colors.append(_color)
                _color = _ds.getOption('DIM_SECONDARY_FONT_COLOR')
                if _color not in _colors:
                    _colors.append(_color)
                _font = _ds.getOption('DIM_PRIMARY_FONT_FAMILY')
                if _font not in _fonts:
                    _fonts.append(_font)
                _font = _ds.getOption('DIM_SECONDARY_FONT_FAMILY')
                if _font not in _fonts:
                    _fonts.append(_font)
                #
                # object may have overridden style values
                #
                _color = _obj.getColor()
                if _color not in _colors: # dimension bar colors
                    _colors.append(_color)
                _pds = _obj.getPrimaryDimstring()
                _color = _pds.getColor() # primary dim text color
                if _color not in _colors:
                    _colors.append(_color)
                _font = _pds.getFamily() # primary dim font
                if _font not in _fonts:
                    _fonts.append(_font)
                _sds = _obj.getSecondaryDimstring()
                _color = _sds.getColor() # secondary dim color
                if _color not in _colors:
                    _colors.append(_color)
                _font = _sds.getFamily() # secondary dim font
                if _font not in _fonts:
                    _fonts.append(_font)
        for _textblock in _layer.getLayerEntities("text"):
            _style = _textblock.getTextStyle()
            if _style not in _textstyles:
                _textstyles.append(_style)
            _font = _style.getFamily()
            if _font not in _fonts:
                _fonts.append(_font)
            _color = _style.getColor()
            if _color not in _colors:
                _colors.append(_color)
            #
            # objects may have overridden the styles
            #
            _font = _textblock.getFamily()
            if _font not in _fonts:
                _fonts.append(_font)
            _color = _textblock.getColor()
            if _color not in _colors:
                _colors.append(_color)
        if _layer.hasSublayers():
            _layers.extend(_layer.getSublayers())
    _colors.sort()
    _styles.sort()
    _linetypes.sort()
    _fonts.sort()
    _dimstyles.sort()
    return _attmap

class EntityMap(object):
    def __init__(self):
        self.__elements = {}
        self.__entities = {}

    def __nonzero__(self):
        return len(self.__elements) != 0

    def saveEntity(self, elem, key, entity):
        _eid = id(elem)
        if _eid not in self.__elements:
            self.__elements[_eid] = elem
        if _eid not in self.__entities:
            self.__entities[_eid] = {}
        _edict = self.__entities[_eid]
        if key in _edict:
            raise KeyError, "Key '%s' already stored for element" % key
        _edict[key] = entity

    def getElements(self):
        return self.__elements.values()

    def getElementKeys(self, element):
        _eid = id(element)
        return self.__entities[_eid].keys()

    def getEntity(self, element, key):
        _eid = id(element)
        return self.__entities[_eid][key]

def save_image(image, filehandle):
    """Save a file.

save_image(image, filehandle)

Argument 'image' should be an Image instance, and 'filehandle'
should be an opened file, pipe, or writeable object.
    """
    _map = {}
    _entmap = EntityMap()
    _doc = xml.dom.minidom.Document()
    try:
        _child = _doc.createElementNS("image", "image:Image")
        _doc.appendChild(_child)
        _attr = _doc.createAttributeNS("xmlns", "xmlns:image")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("xmlns",
                              "xmlns:image",
                              "http://www.pythoncad.org")
        _attr = _doc.createAttributeNS("xmlns", "xmlns:xsi")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("xmlns",
                              "xmlns:xsi",
                              "http://www.w3.org/2001/XMLSchema-instance")
        _attr = _doc.createAttributeNS("xsi", "xsi:schemaLocation")
        _child.setAttributeNodeNS(_attr)
        _child.setAttributeNS("xmlns",
                              "xsi:schemaLocation",
                              "http://www.pythoncad.org")
        _root = _doc.documentElement
        #
        # to only save colors, linetypes, etc. actually used
        # in the drawing, the get_image_attributes() scans
        # the image and stores them and returns them in a
        # dictionary, then the image entities are written out.
        # this approach requires two passes over the image, and
        # it would be nice if these two passes could be combined
        # into a single pass.
        #
        _attmap = _get_image_attributes(image)
        _save_colors(_attmap, _root, _doc, _map)
        _save_linetypes(_attmap, _root, _doc, _map)
        _save_styles(_attmap, _root, _doc, _map)
        _save_font_families(_attmap, _root, _doc, _map)
        _save_dimstyles(_attmap, _root, _doc, _map)
        _save_textstyles(_attmap, _root, _doc, _map)
        _save_units(image, _root, _doc)
        _save_globals(_attmap, _root, _doc, _map)
        _lyrs = _doc.createElementNS("image", "image:Layers")
        _root.appendChild(_lyrs)
        _layers = [image.getTopLayer()]
        _i = 0
        while len(_layers):
            _layer = _layers.pop()
            _map[id(_layer)] = _i
            _child = _doc.createElementNS("image", "image:Layer")
            _lyrs.appendChild(_child)
            _attr = _doc.createAttributeNS("image", "id")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "id", `_i`)
            _attr = _doc.createAttributeNS("image", "name")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "name", _layer.getName())
            _attr = _doc.createAttributeNS("image", "scale")
            _child.setAttributeNodeNS(_attr)
            _child.setAttributeNS("image", "scale", `_layer.getScale()`)
            _parent = _layer.getParentLayer()
            if _parent is not None:
                _pid = id(_parent)
                assert _pid in _map, "Layer %s parent not in map!" % _layer.getName()
                _attr = _doc.createAttributeNS("image", "parent")
                _child.setAttributeNodeNS(_attr)
                _child.setAttributeNS("image", "parent", `_map[_pid]`)
            _save_points(_layer, _child, _doc, _map)
            _save_segments(_layer, _child, _doc, _map)
            _save_circles(_layer, _child, _doc, _map)
            _save_arcs(_layer, _child, _doc, _map)
            _save_hclines(_layer, _child, _doc, _map)
            _save_vclines(_layer, _child, _doc, _map)
            _save_aclines(_layer, _child, _doc, _map)
            _save_clines(_layer, _child, _doc, _map)
            _save_ccircles(_layer, _child, _doc, _map)
            _save_chamfers(_layer, _child, _doc, _map)
            _save_fillets(_layer, _child, _doc, _map)
            _save_leaders(_layer, _child, _doc, _map)
            _save_polylines(_layer, _child, _doc, _map)
            _save_textblocks(_layer, _child, _doc, _map)
            _save_linear_dims(_layer, _child, _doc, _map,
                              _entmap, 'linear_dimension')
            _save_linear_dims(_layer, _child, _doc, _map,
                              _entmap, 'horizontal_dimension')
            _save_linear_dims(_layer, _child, _doc, _map,
                              _entmap, 'vertical_dimension')
            _save_radial_dims(_layer, _child, _doc, _map, _entmap)
            _save_angular_dims(_layer, _child, _doc, _map, _entmap)
            _save_state_bits(_layer, _child, _doc)
            _i = _i + 1
            if _layer.hasSublayers():
                _layers.extend(_layer.getSublayers())
        if _entmap:
            for _elem in _entmap.getElements():
                for _key in _entmap.getElementKeys(_elem):
                    _obj = _entmap.getEntity(_elem, _key)
                    _oid = id(_obj)
                    assert _oid in _map, "Missing object in map: " + `_obj`
                    #if _oid not in _map:
                    # print "missing object in map:"
                    # print "id(): " + `_oid`
                    # print "obj: " + str(_obj)
                    # raise KeyError, "Missing object key"
                    _elem.setAttributeNS("image", _key, `_map[_oid]`)
        #
        # write it out
        #
        _doc.writexml(filehandle, "  ", "  ", "\n")
    finally:
        _doc.unlink()

#
# reload an image
#

class DimMap(object):
    def __init__(self):
        self.__layers = {}
        self.__dims = {}

    def __nonzero__(self):
        return len(self.__layers) != 0

    def saveDim(self, lyr, dtype, dim):
        _lid = id(lyr)
        if _lid not in self.__layers:
            self.__layers[_lid] = lyr
        if _lid not in self.__dims:
            self.__dims[_lid] = {}
        _dtdict = self.__dims[_lid]
        if dtype not in _dtdict:
            _dtdict[dtype] = []
        _dtdict[dtype].append(dim)

    def getLayers(self):
        return self.__layers.values()

    def getLayerDimTypes(self, lyr):
        _lid = id(lyr)
        return self.__dims[_lid].keys()

    def getLayerDims(self, lyr, key):
        _lid = id(lyr)
        return self.__dims[_lid][key][:]

def _apply_dim_overrides(dim, overrides):
    # print "in _apply_dim_overrides()"
    for _key in overrides:
        _val = overrides[_key]
        if _key == 'DIM_OFFSET':
            dim.setOffset(_val)
        elif _key == 'DIM_EXTENSION':
            dim.setExtension(_val)
        elif _key == 'DIM_COLOR':
            dim.setColor(_val)
        elif _key == 'DIM_POSITION':
            dim.setPosition(_val)
        elif _key == 'DIM_ENDPOINT':
            dim.setEndpointType(_val)
        elif _key == 'DIM_ENDPOINT_SIZE':
            dim.setEndpointSize(_val)
        elif _key == 'DIM_DUAL_MODE':
            dim.setDualDimMode(_val)
        elif _key == 'DIM_POSITION_OFFSET':
            dim.setPositionOffset(_val)
        elif _key == 'DIM_DUAL_MODE_OFFSET':
            dim.setDualModeOffset(_val)
        elif _key == 'DIM_PRIMARY_FONT_FAMILY':
            dim.getPrimaryDimstring().setFamily(_val)
        elif _key == 'DIM_PRIMARY_FONT_SIZE':
            dim.getPrimaryDimstring().setSize(_val)
        elif _key == 'DIM_PRIMARY_FONT_WEIGHT':
            dim.getPrimaryDimstring().setWeight(_val)
        elif _key == 'DIM_PRIMARY_FONT_STYLE':
            dim.getPrimaryDimstring().setStyle(_val)
        elif _key == 'DIM_PRIMARY_FONT_COLOR':
            dim.getPrimaryDimstring().setColor(_val)
        elif (_key == 'DIM_PRIMARY_PREFIX' or
              _key == 'RADIAL_DIM_PRIMARY_PREFIX' or
              _key == 'ANGULAR_DIM_PRIMARY_PREFIX'):
            dim.getPrimaryDimstring().setPrefix(_val)
        elif (_key == 'DIM_PRIMARY_SUFFIX' or
              _key == 'RADIAL_DIM_PRIMARY_SUFFIX' or
              _key == 'ANGULAR_DIM_PRIMARY_SUFFIX'):
            dim.getPrimaryDimstring().setSuffix(_val)
        elif _key == 'DIM_PRIMARY_PRECISION':
            dim.getPrimaryDimstring().setPrecision(_val)
        elif _key == 'DIM_PRIMARY_UNITS':
            dim.getPrimaryDimstring().setUnits(_val)
        elif _key == 'DIM_PRIMARY_LEADING_ZERO':
            dim.getPrimaryDimstring().setPrintZero(_val)
        elif _key == 'DIM_PRIMARY_TRAILING_DECIMAL':
            dim.getPrimaryDimstring().setPrintDecimal(_val)
        elif _key == 'DIM_PRIMARY_TEXT_SIZE':
            dim.getPrimaryDimstring().setSize(_val)
        elif _key == 'DIM_PRIMARY_TEXT_ANGLE':
            dim.getPrimaryDimstring().setAngle(_val)
        elif _key == 'DIM_PRIMARY_TEXT_ALIGNMENT':
            dim.getPrimaryDimstring().setAlignment(_val)
        elif _key == 'DIM_SECONDARY_FONT_FAMILY':
            dim.getSecondaryDimstring().setFamily(_val)
        elif _key == 'DIM_SECONDARY_FONT_SIZE':
            dim.getSecondaryDimstring().setSize(_val)
        elif _key == 'DIM_SECONDARY_FONT_WEIGHT':
            dim.getSecondaryDimstring().setWeight(_val)
        elif _key == 'DIM_SECONDARY_FONT_STYLE':
            dim.getSecondaryDimstring().setStyle(_val)
        elif _key == 'DIM_SECONDARY_FONT_COLOR':
            dim.getSecondaryDimstring().setColor(_val)
        elif (_key == 'DIM_SECONDARY_PREFIX' or
              _key == 'RADIAL_DIM_SECONDARY_PREFIX' or
              _key == 'ANGULAR_DIM_SECONDARY_PREFIX'):
            dim.getSecondaryDimstring().setPrefix(_val)
        elif (_key == 'DIM_SECONDARY_SUFFIX' or
              _key == 'RADIAL_DIM_SECONDARY_SUFFIX' or
              _key == 'ANGULAR_DIM_SECONDARY_SUFFIX'):
            dim.getSecondaryDimstring().setSuffix(_val)
        elif _key == 'DIM_SECONDARY_PRECISION':
            dim.getSecondaryDimstring().setPrecision(_val)
        elif _key == 'DIM_SECONDARY_UNITS':
            dim.getSecondaryDimstring().setUnits(_val)
        elif _key == 'DIM_SECONDARY_LEADING_ZERO':
            dim.getSecondaryDimstring().setPrintZero(_val)
        elif _key == 'DIM_SECONDARY_TRAILING_DECIMAL':
            dim.getSecondaryDimstring().setPrintDecimal(_val)
        elif _key == 'DIM_SECONDARY_TEXT_SIZE':
            dim.getSecondaryDimstring().setSize(_val)
        elif _key == 'DIM_SECONDARY_TEXT_ANGLE':
            dim.getSecondaryDimstring().setAngle(_val)
        elif _key == 'DIM_SECONDARY_TEXT_ALIGNMENT':
            dim.getSecondaryDimstring().setAlignment(_val)
        elif _key == 'RADIAL_DIM_DIA_MODE':
            dim.setDiaMode(_val)
        else:
            pass # unused key ...

def _load_dim_options(node, map):
    # print "in _load_dim_options()"
    _options = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == 'image:DimOption':
                _opt = str(_child.getAttribute('opt'))
                if (_opt == 'DIM_COLOR' or
                    _opt == 'DIM_PRIMARY_FONT_COLOR' or
                    _opt == 'DIM_SECONDARY_FONT_COLOR'):
                    _cid = int(_child.getAttribute('cid'))
                    assert _cid in map['color'], 'Color index %d missing' % _cid
                    _val = map['color'][_cid]
                elif (_opt == 'DIM_PRIMARY_FONT_FAMILY' or
                      _opt == 'DIM_SECONDARY_FONT_FAMILY'):
                    _fid = int(_child.getAttribute('fid'))
                    assert _fid in map['family'], 'Font index %d missing' % _fid
                    _val = map['family'][_fid]
                elif (_opt == 'DIM_OFFSET' or
                      _opt == 'DIM_ENDPOINT_SIZE' or
                      _opt == 'DIM_EXTENSION' or
                      _opt == 'DIM_PRIMARY_TEXT_SIZE' or
                      _opt == 'DIM_SECONDARY_TEXT_SIZE' or
                      _opt == 'DIM_DUAL_MODE_OFFSET' or
                      _opt == 'DIM_POSITION_OFFSET' or
                      _opt == 'DIM_THICKNESS' or
                      _opt == 'DIM_PRIMARY_FONT_SIZE' or
                      _opt == 'DIM_SECONDARY_FONT_SIZE' or
                      _opt == 'DIM_PRIMARY_TEXT_ANGLE' or
                      _opt == 'DIM_SECONDARY_TEXT_ANGLE'):
                    _val = float(_child.getAttribute('val'))
                elif (_opt == 'DIM_PRIMARY_PRECISION' or
                      _opt == 'DIM_SECONDARY_PRECISION' or
                      _opt == 'DIM_PRIMARY_UNITS' or
                      _opt == 'DIM_SECONDARY_UNITS' or
                      (_opt == 'DIM_PRIMARY_FONT_SIZE' and False) or
                      (_opt == 'DIM_SECONDARY_FONT_SIZE' and False) or
                      _opt == 'DIM_PRIMARY_FONT_WEIGHT' or
                      _opt == 'DIM_SECONDARY_FONT_WEIGHT' or
                      _opt == 'DIM_PRIMARY_FONT_STYLE' or
                      _opt == 'DIM_SECONDARY_FONT_STYLE' or
                      _opt == 'DIM_POSITION' or
                      _opt == 'DIM_ENDPOINT' or
                      _opt == 'DIM_PRIMARY_TEXT_ALIGNMENT' or
                      _opt == 'DIM_SECONDARY_TEXT_ALIGNMENT'):
                    _val = int(_child.getAttribute('val'))
                elif (_opt == 'DIM_PRIMARY_LEADING_ZERO' or
                      _opt == 'DIM_SECONDARY_LEADING_ZERO' or
                      _opt == 'DIM_PRIMARY_TRAILING_DECIMAL' or
                      _opt == 'DIM_SECONDARY_TRAILING_DECIMAL' or
                      _opt == 'DIM_DUAL_MODE' or
                      _opt == 'RADIAL_DIM_DIA_MODE'):
                    _val = _child.getAttribute('val')
                    if _val == 0 or _val == u'0' or _val == u'False':
                        _val = False
                    elif _val == 1 or _val == u'1' or _val == u'True':
                        _val = True
                elif _opt == 'ANGULAR_DIM_SMALL_ANGLE_MODE': # obsolete
                    _opt = None
                else:
                    _val = _child.getAttribute('val')
                if _opt is not None:
                    _options[_opt] = _val
        _child = _child.nextSibling
    return _options

def _load_linear_dimensions(node, map):
    # print "in _load_linear_dimensions()"
    _dims = []
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if (_child.nodeName == "image:LDim" or
                _child.nodeName == "image:HDim" or
                _child.nodeName == "image:VDim"):
                _dimopts = {}
                _id = int(_child.getAttribute("id"))
                _dimopts['id'] = _id
                _ds = int(_child.getAttribute("ds"))
                _dimopts['ds'] = _ds
                assert _ds in map['dimstyle'], "Missing style %d in map" % _ds
                _l1 = int(_child.getAttribute("l1"))
                _dimopts['l1'] = _l1
                _p1 = int(_child.getAttribute("p1"))
                _dimopts['p1'] = _p1
                _l2 = int(_child.getAttribute("l2"))
                _dimopts['l2'] = _l2
                _p2 = int(_child.getAttribute("p2"))
                _dimopts['p2'] = _p2
                _x = float(_child.getAttribute("x"))
                _dimopts['x'] = _x
                _y = float(_child.getAttribute("y"))
                _dimopts['y'] = _y
                _overrides = _load_dim_options(_child, map)
                for _key in _overrides:
                    _dimopts[_key] = _overrides[_key]
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _dimopts['hidden'] = True
                if _locked:
                    _dimopts['locked'] = True
                _dims.append(_dimopts)
        _child = _child.nextSibling
    return _dims

def _load_radial_dimensions(node, map):
    # print "in _load_radial_dimensions()"
    _rdims = []
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:RDim":
                _dimopts = {}
                _id = int(_child.getAttribute("id"))
                _dimopts['id'] = _id
                _ds = int(_child.getAttribute("ds"))
                assert _ds in map['dimstyle'], "Missing style %d in map" % _ds
                _dimopts['ds'] = _ds
                _l = int(_child.getAttribute("l"))
                _dimopts['l'] = _l
                _c = int(_child.getAttribute("c"))
                _dimopts['c'] = _c
                _x = float(_child.getAttribute("x"))
                _dimopts['x'] = _x
                _y = float(_child.getAttribute("y"))
                _dimopts['y'] = _y
                _overrides = _load_dim_options(_child, map)
                for _key in _overrides:
                    _dimopts[_key] = _overrides[_key]
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _dimopts['hidden'] = True
                if _locked:
                    _dimopts['locked'] = True
                _rdims.append(_dimopts)
        _child = _child.nextSibling
    return _rdims

def _load_angular_dimensions(node, map):
    # print "in _load_angular_dimensions()"
    _adims = []
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:ADim":
                _dimopts = {}
                _id = int(_child.getAttribute("id"))
                _dimopts['id'] = _id
                _ds = int(_child.getAttribute("ds"))
                assert _ds in map['dimstyle'], "Missing style %d in map" % _ds
                _dimopts['ds'] = _ds
                _l1 = int(_child.getAttribute("l1"))
                _dimopts['l1'] = _l1
                _p1 = int(_child.getAttribute("p1"))
                _dimopts['p1'] = _p1
                _l2 = int(_child.getAttribute("l2"))
                _dimopts['l2'] = _l2
                _p2 = int(_child.getAttribute("p2"))
                _dimopts['p2'] = _p2
                _l3 = int(_child.getAttribute("l3"))
                _dimopts['l3'] = _l3
                _p3 = int(_child.getAttribute("p3"))
                _dimopts['p3'] = _p3
                _x = float(_child.getAttribute("x"))
                _dimopts['x'] = _x
                _y = float(_child.getAttribute("y"))
                _dimopts['y'] = _y
                _overrides = _load_dim_options(_child, map)
                for _key in _overrides:
                    _dimopts[_key] = _overrides[_key]
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _dimopts['hidden'] = True
                if _locked:
                    _dimopts['locked'] = True
                _adims.append(_dimopts)
        _child = _child.nextSibling
    return _adims

def _set_graphic_attrs(obj, node, map):
    _ltid = node.getAttribute("linetype")
    if _ltid != "":
        _ltid = int(_ltid)
        assert _ltid in map['linetype'], "Object linetype index %d not in map: %s" % (_ltid, str(obj))
        _lt = map['linetype'][_ltid]
        obj.setLinetype(_lt)
    _cid = node.getAttribute("color")
    if _cid != "":
        _cid = int(_cid)
        assert _cid in map['color'], "Object color index %d not in map: %s" % (_cid, str(obj))
        _c = map['color'][_cid]
        obj.setColor(_c)
    _th = node.getAttribute("thickness")
    if _th != "":
        _th = float(_th)
        obj.setThickness(_th)

def _get_state_bits(node):
    _vis = True
    _locked = False
    _attr = node.getAttribute("visibility")
    if _attr != "":
        if _attr == 0 or _attr == u'0' or _attr == u'False':
            _vis = False
    _attr = node.getAttribute("locked")
    if _attr != "":
        if _attr == 1 or _attr == u'1' or _attr == u'True':
            _locked = True
    return _vis, _locked
            
def _load_textblocks(image, node, map):
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:TextBlock":
                # _id = int(_child.getAttribute("id"))
                _tsid = int(_child.getAttribute("tsid"))
                assert _tsid in map['textstyle'], "TextBlock textstyle id not in map: %d" % _tsid
                _style = map['textstyle'][_tsid]
                _x = float(_child.getAttribute("x"))
                _y = float(_child.getAttribute("y"))
                _text = u''
                if _child.hasChildNodes():
                    _lines = []
                    _linenode = _child.firstChild
                    while _linenode is not None:
                        if _linenode.nodeType == xml.dom.Node.ELEMENT_NODE:
                            if _linenode.nodeName == "image:TextLine":
                                _text = _linenode.getAttribute("text")
                                _lines.append(unicode(_text))
                        _linenode = _linenode.nextSibling
                    if sys.platform == 'mac':
                        _sep = '\r'
                    else:
                        _sep = '\n'
                    _text = _sep.join(_lines)
                _textblock = text.TextBlock(_x, _y, _text, _style)
                #
                # get any possibly overriden style values
                #
                _attr = _child.getAttribute("fid")
                if _attr != "":
                    _fid = int(_attr)
                    _family = map['family'][_fid]
                    _textblock.setFamily(_family)
                _attr = _child.getAttribute("cid")
                if _attr != "":
                    _cid = int(_attr)
                    _color = map['color'][_cid]
                    _textblock.setColor(_color)
                _attr = _child.getAttribute("weight")
                if _attr != "":
                    _weight = text.TextStyle.WEIGHT_NORMAL
                    if _attr == 'normal' or _attr == '0':
                        _weight = text.TextStyle.WEIGHT_NORMAL
                    elif _attr == 'light' or _attr == '1':
                        _weight = text.TextStyle.WEIGHT_LIGHT
                    elif _attr == 'bold' or _attr == '2':
                        _weight = text.TextStyle.WEIGHT_BOLD
                    elif _attr == 'heavy' or _attr == '3':
                        _weight = text.TextStyle.WEIGHT_HEAVY
                    else:
                        sys.stderr.write("Unknown font weight '%s' - using NORMAL\n" % _attr)
                    _textblock.setWeight(_weight)
                _attr = _child.getAttribute("style")
                if _attr != "":
                    _style = text.TextStyle.FONT_NORMAL
                    if _attr == 'normal' or _attr == '0':
                        _style = text.TextStyle.FONT_NORMAL
                    elif _attr == 'oblique' or _attr == '1':
                        _style = text.TextStyle.FONT_OBLIQUE
                    elif _attr == 'italic' or _attr == '2':
                        _style = text.TextStyle.FONT_ITALIC
                    else:
                        sys.stderr.write("Unknown font style '%s' - using NORMAL\n" % _attr)
                    _textblock.setStyle(_style)
                _attr = _child.getAttribute("size")
                if _attr != "":
                    _size = float(_attr)
                    _textblock.setSize(_size)
                _attr = _child.getAttribute("angle")
                if _attr != "":
                    _angle = float(_attr)
                    _textblock.setAngle(_angle)
                _attr = _child.getAttribute("halign")
                if _attr != "":
                    _align = text.TextStyle.ALIGN_LEFT
                    if _attr == 'left' or _attr == '0':
                        _align = text.TextStyle.ALIGN_LEFT
                    elif _attr == 'center' or _attr == '1':
                        _align = text.TextStyle.ALIGN_CENTER
                    elif _attr == 'right' or _attr == '2':
                        _align = text.TextStyle.ALIGN_RIGHT
                    else:
                        sys.stderr.write("Unknown alignment %s - using ALIGN_LEFT\n" % _attr)
                    _textblock.setAlignment(_align)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _textblock.setVisibility(False)
                if _locked:
                    _locked.append(_textblock)
                image.addObject(_textblock)
        _child = _child.nextSibling

def _load_leaders(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Leader":
                # _id = int(_child.getAttribute("id"))
                _pid = int(_child.getAttribute("p1"))
                assert _pid in _pmap, "Leader p1 index %d not in map!" % _pid
                _p1 = _pmap[_pid]
                _pid = int(_child.getAttribute("p2"))
                assert _pid in _pmap, "Leader p2 index %d not in map!" % _pid
                _p2 = _pmap[_pid]
                _pid = int(_child.getAttribute("p3"))
                assert _pid in _pmap, "Leader p3 index %d not in map!" % _pid
                _p3 = _pmap[_pid]
                _sid = int(_child.getAttribute("style"))
                _size = float(_child.getAttribute("size"))
                assert _sid in map['style'], "Leader style index %d not in map!" % _sid
                _style = map['style'][_sid]
                _leader = leader.Leader(_p1, _p2, _p3, _size, _style)
                _set_graphic_attrs(_leader, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _leader.setVisibility(False)
                if _locked:
                    _locked.append(_leader)
                image.addObject(_leader)
        _child = _child.nextSibling

def _load_polylines(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Polyline":
                # _id = int(_child.getAttribute("id"))
                _mpts = eval(_child.getAttribute("points"))
                _pts = []
                for _mpt in _mpts:
                    assert _mpt in _pmap, "Polyline point %d not in map!" % _mpt
                    _pts.append(_pmap[_mpt])

                _sid = int(_child.getAttribute("style"))
                assert _sid in map['style'], "Polyline style index %d not in map!" % _sid
                _st = map['style'][_sid]
                _polyline = polyline.Polyline(_pts, _st)
                _set_graphic_attrs(_polyline, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _polyline.setVisibility(False)
                if _locked:
                    _locked.append(_polyline)
                image.addObject(_polyline)
        _child = _child.nextSibling

def _load_fillets(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _smap = map[_lid]['segment']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Fillet":
                # _id = int(_child.getAttribute("id"))
                _sid = int(_child.getAttribute("s1"))
                assert _sid in _smap, "Fillet segment s1 %d not in map!" % _sid
                _s1 = _smap[_sid]
                _sid = int(_child.getAttribute("s2"))
                assert _sid in _smap, "Fillet segment s2 %s not in map!" % _sid
                _s2 = _smap[_sid]
                _sid = int(_child.getAttribute("style"))
                assert _sid in map['style'], "Fillet style index %d not in map!" % _sid
                _style = map['style'][_sid]
                _radius = float(_child.getAttribute("radius"))
                _fillet = segjoint.Fillet(_s1, _s2, _radius, _style)
                _set_graphic_attrs(_fillet, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _fillet.setVisibility(False)
                if _locked:
                    _locked.append(_fillet)
                image.addObject(_fillet)
        _child = _child.nextSibling

def _load_chamfers(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _smap = map[_lid]['segment']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Chamfer":
                # _id = int(_child.getAttribute("id"))
                _sid = int(_child.getAttribute("s1"))
                assert _sid in _smap, "Chamfer segment s1 %d not in map!" % _sid
                _s1 = _smap[_sid]
                _sid = int(_child.getAttribute("s2"))
                assert _sid in _smap, "Chamfer segment s2 %s not in map!" % _sid
                _s2 = _smap[_sid]
                _sid = int(_child.getAttribute("style"))
                assert _sid in map['style'], "Chamfer style index %d not in map!" % _sid
                _style = map['style'][_sid]
                _length = float(_child.getAttribute("length"))
                _chamfer = segjoint.Chamfer(_s1, _s2, _length, _style)
                _set_graphic_attrs(_chamfer, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _chamfer.setVisibility(False)
                if _locked:
                    _locked.append(_chamfer)
                image.addObject(_chamfer)
        _child = _child.nextSibling

def _load_ccircles(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:CCircle":
                # _id = int(_child.getAttribute("id"))
                _cid = int(_child.getAttribute("cp"))
                assert _cid in _pmap, "CCircle center index %d not in map!" % _cid
                _cen = _pmap[_cid]
                _rad = float(_child.getAttribute("r"))
                _cc = ccircle.CCircle(_cen, _rad)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _cc.setVisibility(False)
                if _locked:
                    _locked.append(_cc)
                image.addObject(_cc)
        _child = _child.nextSibling

def _load_clines(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:CLine":
                # _id = int(_child.getAttribute("id"))
                _pid = int(_child.getAttribute("p1"))
                assert _pid in _pmap, "CLine p1 index %d not in map!" % _pid
                _p1 = _pmap[_pid]
                _pid = int(_child.getAttribute("p2"))
                assert _pid in _pmap, "CLine p2 index %d not in map!" % _pid
                _p2 = _pmap[_pid]
                _cl = cline.CLine(_p1, _p2)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _cl.setVisibility(False)
                if _locked:
                    _locked.append(_cl)
                image.addObject(_cl)
        _child = _child.nextSibling

def _load_aclines(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:ACLine":
                #_id = int(_child.getAttribute("id"))
                _pid = int(_child.getAttribute("location"))
                _angle = float(_child.getAttribute("angle"))
                assert _pid in _pmap, "ACLine location index %d not in map!" % _pid
                _loc = _pmap[_pid]
                _acl = acline.ACLine(_loc, _angle)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _acl.setVisibility(False)
                if _locked:
                    _locked.append(_acl)
                image.addObject(_acl)
        _child = _child.nextSibling

def _load_vclines(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:VCLine":
                # _id = int(_child.getAttribute("id"))
                _pid = int(_child.getAttribute("location"))
                assert _pid in _pmap, "VCLine location index %d not in map!" % _pid
                _loc = _pmap[_pid]
                _vcl = vcline.VCLine(_loc)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _vcl.setVisibility(False)
                if _locked:
                    _locked.append(_vcl)
                image.addObject(_vcl)
        _child = _child.nextSibling

def _load_hclines(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:HCLine":
                # _id = int(_child.getAttribute("id"))
                _pid = int(_child.getAttribute("location"))
                assert _pid in _pmap, "HCLine location index %d not in map!" % _pid
                _loc = _pmap[_pid]
                _hcl = hcline.HCLine(_loc)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _hcl.setVisibility(False)
                if _locked:
                    _locked.append(_hcl)
                image.addObject(_hcl)
        _child = _child.nextSibling

def _load_arcs(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _amap = {}
    map[_lid]['arc'] = _amap
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Arc":
                _id = int(_child.getAttribute("id"))
                _cid = int(_child.getAttribute("cp"))
                assert _cid in _pmap, "Arc center index %d not in map!" % _cid
                _cen = _pmap[_cid]
                _rad = float(_child.getAttribute("r"))
                _sa = float(_child.getAttribute("sa"))
                _ea = float(_child.getAttribute("ea"))
                _sid = int(_child.getAttribute("style"))
                assert _sid in map['style'], "Arc style index %d not in map!" % _sid
                _style = map['style'][_sid]
                _arc = arc.Arc(_cen, _rad, _sa, _ea, _style)
                _set_graphic_attrs(_arc, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _arc.setVisibility(False)
                if _locked:
                    _locked.append(_arc)
                _amap[_id] = _arc
                image.addObject(_arc)
        _child = _child.nextSibling

def _load_circles(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _cmap = {}
    map[_lid]['circle'] = _cmap
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Circle":
                _id = int(_child.getAttribute("id"))
                _cid = int(_child.getAttribute("cp"))
                assert _cid in _pmap, "Circle center index %d not in map!" % _cid
                _cen = _pmap[_cid]
                _rad = float(_child.getAttribute("r"))
                _sid = int(_child.getAttribute("style"))
                assert _sid in map['style'], "Circle style index %d not in map!" % _sid
                _style = map['style'][_sid]
                _circle = circle.Circle(_cen, _rad, _style)
                _set_graphic_attrs(_circle, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _circle.setVisibility(False)
                if _locked:
                    _locked.append(_circle)
                image.addObject(_circle)
                _cmap[_id] = _circle
        _child = _child.nextSibling

def _load_segments(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = map[_lid]['point']
    _smap = {}
    map[_lid]['segment'] = _smap
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Segment":
                _id = int(_child.getAttribute("id"))
                _pid = int(_child.getAttribute("p1"))
                assert _pid in _pmap, "Segment p1 index %d not in map!" % _pid
                _p1 = _pmap[_pid]
                _pid = int(_child.getAttribute("p2"))
                assert _pid in _pmap, "Segment p2 index %d not in map!" % _pid
                _p2 = _pmap[_pid]
                _sid = int(_child.getAttribute("style"))
                assert _sid in map['style'], "Segment style index %d not in map!" % _sid
                _style = map['style'][_sid]
                _seg = segment.Segment(_p1, _p2, _style)
                _set_graphic_attrs(_seg, _child, map)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _seg.setVisibility(False)
                if _locked:
                    _locked.append(_seg)
                image.addObject(_seg)
                _smap[_id] = _seg
        _child = _child.nextSibling

def _load_points(image, node, map):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    _pmap = {}
    map[_lid]['point'] = _pmap
    _locked = map['locked']
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Point":
                _id = int(_child.getAttribute("id"))
                _x = float(_child.getAttribute("x"))
                _y = float(_child.getAttribute("y"))
                _p = point.Point(_x, _y)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _p.setVisibility(False)
                if _locked:
                    _locked.append(_p)
                image.addObject(_p)
                _pmap[_id] = _p
        _child = _child.nextSibling

def _load_layer(image, node, map, dimmap):
    _layer = image.getActiveLayer()
    _lid = id(_layer)
    map[_lid] = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            _name = _child.nodeName
            if _name == "image:Points":
                _load_points(image, _child, map)
            elif _name == "image:Segments":
                _load_segments(image, _child, map)
            elif _name == "image:Circles":
                _load_circles(image, _child, map)
            elif _name == "image:Arcs":
                _load_arcs(image, _child, map)
            elif _name == "image:HCLines":
                _load_hclines(image, _child, map)
            elif _name == "image:VCLines":
                _load_vclines(image, _child, map)
            elif _name == "image:ACLines":
                _load_aclines(image, _child, map)
            elif _name == "image:CLines":
                _load_clines(image, _child, map)
            elif _name == "image:CCircles":
                _load_ccircles(image, _child, map)
            elif _name == "image:Fillets":
                _load_fillets(image, _child, map)
            elif _name == "image:Chamfers":
                _load_chamfers(image, _child, map)
            elif _name == "image:Leaders":
                _load_leaders(image, _child, map)
            elif _name == "image:Polylines":
                _load_polylines(image, _child, map)
            elif _name == "image:TextBlocks":
                _load_textblocks(image, _child, map)
            elif _name == "image:LDims":
                for _dim in _load_linear_dimensions(_child, map):
                    dimmap.saveDim(_layer, 'linear', _dim)
            elif _name == "image:HDims":
                for _dim in _load_linear_dimensions(_child, map):
                    dimmap.saveDim(_layer, 'horizontal', _dim)
            elif _name == "image:VDims":
                for _dim in _load_linear_dimensions(_child, map):
                    dimmap.saveDim(_layer, 'vertical', _dim)
            elif _name == "image:RDims":
                for _dim in _load_radial_dimensions(_child, map):
                    dimmap.saveDim(_layer, 'radial', _dim)
            elif _name == "image:ADims":
                for _dim in _load_angular_dimensions(_child, map):
                    dimmap.saveDim(_layer, 'angular', _dim)
        _child = _child.nextSibling

def _add_linear_dimension(dim, map, dimtype, image, lyr):
    assert 'ds' in dim, "Dim missing key 'ds': " + `dim`
    _dsid = dim['ds']
    assert _dsid in map['dimstyle'], "Missing dimstyle id %d" % _dsid
    _ds = map['dimstyle'][_dsid]
    del dim['ds']
    assert 'l1' in dim, "Dim missing key 'l1': " + `dim`
    _lid = dim['l1']
    del dim['l1']
    assert _lid in map['layer'], "Missing layer id %d" % _lid
    _l1 = map['layer'][_lid]
    assert 'p1' in dim, "Dim missing key 'p1': " + `dim`
    _pid = dim['p1']
    del dim['p1']
    _lid = id(_l1)
    assert _pid in map[_lid]['point'], "Missing p1 key %d in map" % _pid
    _p1 = map[_lid]['point'][_pid]
    assert 'l2' in dim, "Dim missing key 'l2': " + `dim`
    _lid = dim['l2']
    del dim['l2']
    assert _lid in map['layer'], "Missing layer id %d" % _lid
    _l2 = map['layer'][_lid]
    assert 'p2' in dim, "Dim missing key 'p2': " + `dim`
    _pid = dim['p2']
    del dim['p2']
    _lid = id(_l2)
    assert _pid in map[_lid]['point'], "Missing p2 key %d in map" % _pid
    _p2 = map[_lid]['point'][_pid]
    assert 'x' in dim, "Dim missing key 'x': " + `dim`
    _x = dim['x']
    del dim['x']
    assert 'y' in dim, "Dim missing key 'y': " + `dim`
    _y = dim['y']
    del dim['y']
    _ldim = dimtype(_l1, _p1, _l2, _p2, _x, _y, _ds)
    if 'id' in dim:
        del dim['id']
    # print "remaining keys ..."
    # for _key in dim:
        # print "key: %s" % _key
        # print "value: " + `dim[_key]`
    if len(dim):
        _apply_dim_overrides(_ldim, dim)
    if 'hidden' in dim:
        _ldim.setVisibility(False)
    if 'locked' in dim:
        _ldim.setLock(True)
    image.ignore('modified')
    try:
        image.addObject(_ldim, lyr)
    finally:
        image.receive('modified')
    _log = lyr.getLog() # fixme - this will go away
    if _log is not None:
        _log.clear()

def _add_radial_dimension(dim, map, image, lyr):
    assert 'id' in dim, "Dim missing key 'id': " + `dim`
    assert 'ds' in dim, "Dim missing key 'ds': " + `dim`
    _dsid = dim['ds']
    assert _dsid in map['dimstyle'], "Missing dimstyle id %d" % _dsid
    _ds = map['dimstyle'][_dsid]
    del dim['ds']
    assert 'l' in dim, "Dim missing key 'l': " + `dim`
    _lid = dim['l']
    del dim['l']
    assert _lid in map['layer'], "Missing layer id %d" % _lid
    _cl = map['layer'][_lid]
    assert 'c' in dim, "Dim missing key 'c': " + `dim`
    _cid = dim['c']
    del dim['c']
    _lid = id(_cl)
    assert _cid in map[_lid]['circle'], "Missing circle key %d" % _cid
    _circ = map[_lid]['circle'][_cid]
    assert 'x' in dim, "Dim missing key 'x': " + `dim`
    _x = dim['x']
    del dim['x']
    assert 'y' in dim, "Dim missing key 'y': " + `dim`
    _y = dim['y']
    del dim['y']
    _rdim = dimension.RadialDimension(_cl, _circ, _x, _y, _ds)
    if 'id' in dim:
        del dim['id']
    # print "remaining keys ..."
    # for _key in dim:
        # print "key: %s" % key
        # print "value: " + `dim[_key]`
    if len(dim):
        _apply_dim_overrides(_rdim, dim)
    if 'hidden' in dim:
        _rdim.setVisibility(False)
    if 'locked' in dim:
        _rdim.setLock(True)
    image.ignore('modified')
    try:
        image.addObject(_rdim, lyr)
    finally:
        image.receive('modified')
    _log = lyr.getLog() # fixme - this will go away
    if _log is not None:
        _log.clear()

def _add_angular_dimension(dim, map, image, lyr):
    assert 'id' in dim, "Dim missing key 'id': " + `dim`
    assert 'ds' in dim, "Dim missing key 'ds': " + `dim`
    _dsid = dim['ds']
    assert _dsid in map['dimstyle'], "Missing dimstyle id %d" % _dsid
    _ds = map['dimstyle'][_dsid]
    del dim['ds']
    assert 'l1' in dim, "Dim missing key 'l1': " + `dim`
    _lid = dim['l1']
    del dim['l1']
    assert _lid in map['layer'], "Missing layer id %d" % _lid
    _l1 = map['layer'][_lid]
    assert 'p1' in dim, "Dim missing key 'p1': " + `dim`
    _pid = dim['p1']
    del dim['p1']
    _lid = id(_l1)
    assert _pid in map[_lid]['point'], "Missing p1 id %d" % _pid
    _p1 = map[_lid]['point'][_pid]
    assert 'l2' in dim, "Dim missing key 'l2': " + `dim`
    _lid = dim['l2']
    del dim['l2']
    assert _lid in map['layer'], "Missing layer id %d" % _lid
    _l2 = map['layer'][_lid]
    assert 'p2' in dim, "Dim missing key 'p2': " + `dim`
    _pid = dim['p2']
    del dim['p2']
    _lid = id(_l2)
    assert _pid in map[_lid]['point'], "Missing p2 id %d" % _pid
    _p2 = map[_lid]['point'][_pid]
    assert 'l3' in dim, "Dim missing key 'l3': " + `dim`
    _lid = dim['l3']
    del dim['l3']
    assert _lid in map['layer'], "Missing layer id %d" % _lid
    _l3 = map['layer'][_lid]
    assert 'p3' in dim, "Dim missing key 'p3': " + `dim`
    _pid = dim['p3']
    del dim['p3']
    _lid = id(_l3)
    assert _pid in map[_lid]['point'], "Missing p3 id %d" % _pid
    _p3 = map[_lid]['point'][_pid]
    assert 'x' in dim, "Dim missing key 'x': " + `dim`
    _x = dim['x']
    del dim['x']
    assert 'y' in dim, "Dim missing key 'y': " + `dim`
    _y = dim['y']
    del dim['y']
    _adim = dimension.AngularDimension(_l1, _p1, _l2, _p2, _l3, _p3,
                                       _x, _y, _ds)
    if 'id' in dim:
        del dim['id']
    # print "remaining keys ..."
    # for _key in dim:
        # print "key: %s" % _key
        # print "value: " + `dim[_key]`
    if len(dim):
        _apply_dim_overrides(_adim, dim)
    if 'hidden' in dim:
        _adim.setVisibility(False)
    if 'locked' in dim:
        _adim.setLock(True)
    image.ignore('modified')
    try:
        image.addObject(_adim, lyr)
    finally:
        image.receive('modified')
    _log = lyr.getLog() # fixme - this will go away
    if _log is not None:
        _log.clear()

def _load_layers(image, node, map):
    _lmap = {}
    map['layer'] = _lmap
    map['locked'] = []
    _dimmap = DimMap()
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Layer":
                _id = int(_child.getAttribute("id"))
                _name = str(_child.getAttribute("name"))
                _scale = float(_child.getAttribute("scale"))
                _pid = _child.getAttribute("parent")
                if _pid == "": # top layer created with image
                    _layer = image.getTopLayer()
                    _layer.setName(_name)
                else:
                    _pid = int(_pid)
                    assert _pid in _lmap, "Layer parent id %d missing in map!" % _pid
                    _parent = _lmap[_pid]
                    _layer = layer.Layer(_name)
                    image.addChildLayer(_layer, _parent)
                _layer.setScale(_scale)
                _vis, _locked = _get_state_bits(_child)
                if not _vis:
                    _layer.setVisibility(False)
                if _locked:
                    _locked.append(_layer)
                image.setActiveLayer(_layer)
                _lmap[_id] = _layer
                image.ignore('modified')
                try:
                    _load_layer(image, _child, map, _dimmap)
                finally:
                    image.receive('modified')
                _log = _layer.getLog() # fixme - this will go away
                if _log is not None:
                    _log.clear()
        _child = _child.nextSibling
    if _dimmap:
        for _layer in _dimmap.getLayers():
            for _dimtype in _dimmap.getLayerDimTypes(_layer):
                for _dim in _dimmap.getLayerDims(_layer, _dimtype):
                    if _dimtype == 'linear':
                        _add_linear_dimension(_dim, map,
                                              dimension.LinearDimension,
                                              image, _layer)
                    elif _dimtype == 'horizontal':
                        _add_linear_dimension(_dim, map,
                                              dimension.HorizontalDimension,
                                              image, _layer)
                    elif _dimtype == 'vertical':
                        _add_linear_dimension(_dim, map,
                                              dimension.VerticalDimension,
                                              image, _layer)
                    elif _dimtype == 'radial':
                        _add_radial_dimension(_dim, map, image, _layer)
                    elif _dimtype == 'angular':
                        _add_angular_dimension(_dim, map, image, _layer)
                    else:
                        raise TypeError, "Unknown dimension type %s" % _dimtype

def _load_textstyles(image, node, map):
    map['textstyle'] = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:TextStyle":
                _id = int(_child.getAttribute("id"))
                _name= _child.getAttribute("name")
                _cid = int(_child.getAttribute("cid"))
                assert _cid in map['color'], "Color ID missing from map: %d" % _cid
                _color = map['color'][_cid]
                _fid = int(_child.getAttribute("fid"))
                assert _fid in map['family'], "Font ID missing from map: %d" % _fid
                _family = map['family'][_fid]
                _attr = _child.getAttribute("weight")
                _weight = text.TextStyle.WEIGHT_NORMAL
                if _attr == 'normal' or _attr == '0':
                    _weight = text.TextStyle.WEIGHT_NORMAL
                elif _attr == 'light' or _attr == '1':
                    _weight = text.TextStyle.WEIGHT_LIGHT
                elif _attr == 'bold' or _attr == '2':
                    _weight = text.TextStyle.WEIGHT_BOLD
                elif _attr == 'heavy' or _attr == '3':
                    _weight = text.TextStyle.WEIGHT_HEAVY
                else:
                    sys.stderr.write("Unknown font weight '%s' - using NORMAL\n" % _attr)
                #
                # size used to be integer in older TextStyles
                #
                _size = float(_child.getAttribute("size"))
                _attr = _child.getAttribute("style")
                _style = text.TextStyle.FONT_NORMAL
                if _attr == 'normal' or _attr == '0':
                    _style = text.TextStyle.FONT_NORMAL
                elif _attr == 'oblique' or _attr == '1':
                    _style = text.TextStyle.FONT_OBLIQUE
                elif _attr == 'italic' or _attr == '2':
                    _style = text.TextStyle.FONT_ITALIC
                else:
                    sys.stderr.write("Unknown font style '%s' - using NORMAL\n" % _attr)
                #
                # angle not present in older TextStyles
                #
                _angle = 0.0
                _attr = _child.getAttribute("angle")
                if _attr != "":
                    _angle = float(_attr)
                #
                # alignment not present in older TextStyles
                #
                _align = text.TextStyle.ALIGN_LEFT
                _attr = _child.getAttribute("halign")
                if _attr != "":
                    if _attr == 'left' or _attr == '0':
                        _align = text.TextStyle.ALIGN_LEFT
                    elif _attr == 'center' or _attr == '1':
                        _align = text.TextStyle.ALIGN_CENTER
                    elif _attr == 'right' or _attr == '2':
                        _align = text.TextStyle.ALIGN_RIGHT
                    else:
                        sys.stderr.write("Unknown alignment %s - using ALIGN_LEFT\n" % _attr)
                _textstyle = text.TextStyle(_name,
                                            family=_family,
                                            size=_size,
                                            style=_style,
                                            weight=_weight,
                                            color=_color,
                                            angle=_angle,
                                            align=_align)
                image.addTextStyle(_textstyle)
                map['textstyle'][_id] = _textstyle
        _child = _child.nextSibling

def _load_dimstyles(image, node, map):
    map['dimstyle'] = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:DimStyle":
                _id = int(_child.getAttribute("id"))
                _name = _child.getAttribute("name")
                _dsopts = _load_dim_options(_child, map)
                # print "print keys ..."
                _dskeys = _dsopts.keys()
                _dskeys.sort()
                # for key in dskeys:
                    # print "key: " + key + "; value: " + `dsopts[key]`
                _dimstyle = dimension.DimStyle(_name, _dsopts)
                if image.hasDimStyle(_dimstyle):
                    for _ds in image.getImageEntities('dimstyle'):
                        if _dimstyle == _ds:
                            map['dimstyle'][_id] = _ds
                else:
                    image.addDimStyle(_dimstyle)
                    map['dimstyle'][_id] = _dimstyle
        _child = _child.nextSibling

def _load_font_families(image, node, map):
    map['family'] = {}
    _child = node.firstChild
    _families = image.getImageEntities('font')
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:FontFamily":
                _id = int(_child.getAttribute("id"))
                _family = _child.getAttribute("name")
                if _family in _families:
                    for _f in _families:
                        if _f == _family:
                            map['family'][_id] = _f
                else:
                    map['family'][_id] = _family
        _child = _child.nextSibling

def _load_styles(image, node, map):
    map['style'] = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Style":
                _id = int(_child.getAttribute("id"))
                _cid = int(_child.getAttribute("cid"))
                assert _cid in map['color'], "Color index %d missing" % _cid
                _color = map['color'][_cid]
                _ltid = int(_child.getAttribute("ltid"))
                assert _ltid in map['linetype'], "Linetype index %d missing" % _ltid
                _lt = map['linetype'][_ltid]
                _name = _child.getAttribute("name")
                _th = float(_child.getAttribute("thickness"))
                _style = style.Style(_name, _lt, _color, _th)
                if image.hasStyle(_style):
                    for _st in image.getImageEntities('style'):
                        if _style == _st:
                            map['style'][_id] = _st
                            break
                else:
                    image.addStyle(_style)
                    map['style'][_id] = _style
        _child = _child.nextSibling

def _load_globals(image, node, map):
#
# for now, assumes globals are ONLY colors
#
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Global":
                _key = str(_child.getAttribute("key"))
                _cid = int(_child.getAttribute("cid"))
                assert _cid in map['color'], "Color index %d missing" % _cid
                _color = map['color'][_cid]
                (_r, _g, _b) = _color.getColors()
                image.setOption(_key, color.get_color(_r, _g, _b))
        _child = _child.nextSibling


def _load_linetypes(image, node, map):
    map['linetype'] = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Linetype":
                _id = int(_child.getAttribute("id"))
                _name = _child.getAttribute("name")
                _pat = _child.getAttribute("pattern")
                if _pat == "None":
                    _pat = None
                else:
                    _pat = eval(_pat)
                _linetype = linetype.Linetype(_name, _pat)
                if image.hasLinetype(_linetype):
                    for _lt in image.getImageEntities('linetype'):
                        if _lt == _linetype:
                            map['linetype'][_id] = _lt
                            break
                else:
                    image.addLinetype(_linetype)
                    map['linetype'][_id] = _linetype
        _child = _child.nextSibling

def _load_colors(image, node, map):
    map['color'] = {}
    _child = node.firstChild
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            if _child.nodeName == "image:Color":
                _id = int(_child.getAttribute("id"))
                _r = int(_child.getAttribute("r"))
                _g = int(_child.getAttribute("g"))
                _b = int(_child.getAttribute("b"))
                _color = color.get_color(_r, _g, _b)
                if image.hasColor(_color):
                    for _col in image.getImageEntities('color'):
                        if _color == _col:
                            map['color'][_id] = _col
                else:
                    image.addColor(_color)
                    map['color'][_id] = _color
        _child = _child.nextSibling

def load_image(image, filehandle):
    """Load an image from a filename or standard input

load_image(image, filehandle)

The argument image should be an empty image. The
filehandle argument should be an opened file object
that can be passed to the XML parser.
    """
    _objmap = {}
    _doc = xml.dom.minidom.parse(filehandle)
    _root = _doc.documentElement
    if _root.nodeName != "image:Image":
        _doc.unlink()
        raise ValueError, "Expected 'image:Image' but got '%s' as document root!" % _root.name
    _child = _root.firstChild
    while _child.nodeType == xml.dom.Node.TEXT_NODE:
        _child = _child.nextSibling
    if _child.nodeName != "image:Colors":
        _doc.unlink()
        raise ValueError, "Expected 'image:Colors' but got '%s'" % _child.nodeName
    _load_colors(image, _child, _objmap)
    _child = _child.nextSibling
    while _child.nodeType == xml.dom.Node.TEXT_NODE:
        _child = _child.nextSibling
    if _child.nodeName != "image:Linetypes":
        raise ValueError, "Expected 'image:Linetypes' but got '%s'" % _child.nodeName
    _load_linetypes(image, _child, _objmap)
    _child = _child.nextSibling
    while _child.nodeType == xml.dom.Node.TEXT_NODE:
        _child = _child.nextSibling
    if _child.nodeName != "image:Styles":
        _doc.unlink()
        raise ValueError, "Expected 'image:Styles' but got '%s'" % _child.nodeName
    _load_styles(image, _child, _objmap)
    _child = _child.nextSibling
    while _child is not None:
        if _child.nodeType == xml.dom.Node.ELEMENT_NODE:
            _name = _child.nodeName
            if _name == "image:Units":
                _attr = _child.getAttribute("unit")
                if _attr == 'millimeters' or _attr == '0':
                    _unit = units.MILLIMETERS
                elif _attr == 'micrometers' or _attr == '1':
                    _unit = units.MICROMETERS
                elif _attr == 'meters' or _attr == '2':
                    _unit = units.METERS
                elif _attr == 'kilometers' or _attr == '3':
                    _unit = units.KILOMETERS
                elif _attr == 'inches' or _attr == '4':
                    _unit = units.INCHES
                elif _attr == 'feet' or _attr == '5':
                    _unit = units.FEET
                elif _attr == 'yards' or _attr == '6':
                    _unit = units.YARDS
                elif _attr == 'miles' or _attr == '7':
                    _unit = units.MILES
                else:
                    sys.stderr.write("Unknown unit '%s' - using MILLIMETERS\n" % _attr)
                    _unit = units.MILLIMETERS
                image.setUnits(_unit)
            elif _name == "image:FontFamilies":
                _load_font_families(image, _child, _objmap)
            elif _name == "image:DimStyles":
                _load_dimstyles(image, _child, _objmap)
            elif _name == "image:TextStyles":
                _load_textstyles(image, _child, _objmap)
            elif _name == "image:Globals":
                _load_globals(image, _child, _objmap)
            elif _name == "image:Layers":
                _load_layers(image, _child, _objmap)
                for _obj in _objmap['locked']:
                    _obj.setLock(True)
        _child = _child.nextSibling
    _doc.unlink()