Thuban/Model/load.py

# Copyright (C) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Jan-Oliver Wagner <[email protected]>
# Bernhard Herzog <[email protected]>
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with GRASS for details.

"""
Parser for thuban session files.
"""

__version__ = "$Revision$"

import string, os

import xml.sax
import xml.sax.handler
from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException

from Thuban import _

from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
     FIELDTYPE_STRING

from Thuban.Model.session import Session
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer, RasterLayer
from Thuban.Model.color import Color
from Thuban.Model.proj import Projection
from Thuban.Model.range import Range
from Thuban.Model.classification import Classification, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
    ClassGroupProperties
from Thuban.Model.data import DerivedShapeStore, ShapefileStore
from Thuban.Model.table import DBFTable
from Thuban.Model.transientdb import TransientJoinedTable

class LoadError(Exception):
    pass

from Thuban.Model.xmlreader import XMLReader
import resource 

def parse_color(color):
    """Return the color object for the string color.

    Color may be either 'None' or of the form '#RRGGBB' in the usual
    HTML color notation
    """
    color = string.strip(color)
    if color == "None":
        result = Color.Transparent
    elif color[0] == '#':
        if len(color) == 7:
            r = string.atoi(color[1:3], 16) / 255.0
            g = string.atoi(color[3:5], 16) / 255.0
            b = string.atoi(color[5:7], 16) / 255.0
            result = Color(r, g, b)
        else:
            raise ValueError(_("Invalid hexadecimal color specification %s")
                             % color)
    else:
        raise ValueError(_("Invalid color specification %s") % color)
    return result

class AttrDesc:

    def __init__(self, name, required = False, default = "",
                 conversion = None):
        if not isinstance(name, tuple):
            fullname = (None, name)
        else:
            fullname = name
            name = name[1]
        self.name = name
        self.fullname = fullname
        self.required = required
        self.default = default
        self.conversion = conversion

        # set by the SessionLoader's check_attrs method
        self.value = None


class SessionLoader(XMLReader):

    def __init__(self):
        """Inititialize the Sax handler."""
        XMLReader.__init__(self)

        self.theSession = None
        self.aMap = None
        self.aLayer = None

        # Map ids used in the thuban file to the corresponding objects
        # in the session
        self.idmap = {}

        dispatchers = {
            'session'       : ("start_session",        "end_session"),
            'fileshapesource': ("start_fileshapesource", None),
            'derivedshapesource': ("start_derivedshapesource", None),
            'filetable': ("start_filetable", None),
            'jointable': ("start_jointable", None),

            'map'           : ("start_map",            "end_map"),
            'projection'    : ("start_projection",     "end_projection"),
            'parameter'     : ("start_parameter",      None),
            'layer'         : ("start_layer",          "end_layer"),
            'rasterlayer'   : ("start_rasterlayer",    "end_rasterlayer"),
            'classification': ("start_classification", "end_classification"),
            'clnull'        : ("start_clnull",         "end_clnull"),
            'clpoint'       : ("start_clpoint",        "end_clpoint"),
            'clrange'       : ("start_clrange",        "end_clrange"),
            'cldata'        : ("start_cldata",         "end_cldata"),
            'table'         : ("start_table",          "end_table"),
            'labellayer'    : ("start_labellayer",     None),
            'label'         : ("start_label",          None)}

        # all dispatchers should be used for the 0.8 namespace
        xmlns = "http://thuban.intevation.org/dtds/thuban-0.8.dtd"
        for key, value in dispatchers.items():
            dispatchers[(xmlns, key)] = value

        XMLReader.AddDispatchers(self, dispatchers)

    def start_session(self, name, qname, attrs):
        self.theSession = Session(self.encode(attrs.get((None, 'title'),
                                                        None)))

    def end_session(self, name, qname):
        pass

    def check_attrs(self, element, attrs, descr):
        """Check and convert some of the attributes of an element

        Parameters:
           element -- The element name
           attrs -- The attrs mapping as passed to the start_* methods
           descr -- Sequence of attribute descriptions (AttrDesc instances)

        Return a dictionary containig normalized versions of the
        attributes described in descr. The keys of that dictionary are
        the name attributes of the attribute descriptions. The attrs
        dictionary will not be modified.

        If the attribute is required, i.e. the 'required' attribute of
        the descrtiption is true, but it is not in attrs, raise a
        LoadError.

        If the attribute has a default value and it is not present in
        attrs, use that default value as the value in the returned dict.

        If a conversion is specified, convert the value before putting
        it into the returned dict. The following conversions are
        available:

           'filename' -- The attribute is a filename.

                         If the filename is a relative name, interpret
                         it relative to the directory containing the
                         .thuban file and make it an absolute name

           'shapestore' -- The attribute is the ID of a shapestore
                           defined earlier in the .thuban file. Look it
                           up self.idmap

           'table' -- The attribute is the ID of a table or shapestore
                      defined earlier in the .thuban file. Look it up
                      self.idmap. If it's the ID of a shapestore the
                      value will be the table of the shapestore.
        """
        normalized = {}

        for d in descr:
            if d.required and not attrs.has_key(d.fullname):
                pass
            #raise LoadError("Element %s requires an attribute %r"
            #                    % (element, d.name))
            value = attrs.get(d.fullname, d.default)

            if d.conversion == "shapesource":
                if value in self.idmap:
                    value = self.idmap[value]
                else:
                    raise LoadError("Element %s requires an already defined ID"
                                    " in attribute %r"
                                    % (element, d.name))
            elif d.conversion == "table":
                if value in self.idmap:
                    value = self.idmap[value]
                    if isinstance(value, ShapefileStore):
                        value = value.Table()
                else:
                    raise LoadError("Element %s requires an already defined ID"
                                    " in attribute %r"
                                    % (element, d.name))
            elif d.conversion == "filename":
                value = os.path.abspath(os.path.join(self.GetDirectory(),
                                                     value))

            normalized[d.name] = value
        return normalized

    def start_fileshapesource(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                  [AttrDesc("id", True),
                                   AttrDesc("filename", True,
                                            conversion = "filename"),
                                   AttrDesc("filetype", True)])
        ID = attrs["id"]
        filename = attrs["filename"]
        filetype = attrs["filetype"]
        if filetype != "shapefile":
            raise LoadError("shapesource filetype %r not supported" % filetype)
        self.idmap[ID] = self.theSession.OpenShapefile(filename)

    def start_derivedshapesource(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("shapesource", True,
                                           conversion = "shapesource"),
                                  AttrDesc("table", True, conversion="table")])
        self.idmap[attrs["id"]] = DerivedShapeStore(attrs["shapesource"],
                                                    attrs["table"])

    def start_filetable(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("title", True),
                                  AttrDesc("filename", True,
                                           conversion = "filename"),
                                  AttrDesc("filetype")])
        filetype = attrs["filetype"]
        if filetype != "DBF":
            raise LoadError("shapesource filetype %r not supported" % filetype)
        table = DBFTable(attrs["filename"])
        table.SetTitle(attrs["title"])
        self.idmap[attrs["id"]] = self.theSession.AddTable(table)

    def start_jointable(self, name, qname, attrs):
        attrs = self.check_attrs(name, attrs,
                                 [AttrDesc("id", True),
                                  AttrDesc("title", True),
                                  AttrDesc("left", True, conversion="table"),
                                  AttrDesc("leftcolumn", True),
                                  AttrDesc("right", True, conversion="table"),
                                  AttrDesc("rightcolumn")])
        table = TransientJoinedTable(self.theSession.TransientDB(),
                                     attrs["left"], attrs["leftcolumn"],
                                     attrs["right"], attrs["rightcolumn"])
        table.SetTitle(attrs["title"])
        self.idmap[attrs["id"]] = self.theSession.AddTable(table)

    def start_map(self, name, qname, attrs):
        """Start a map."""
        self.aMap = Map(attrs.get((None, 'title'), None))

    def end_map(self, name, qname):
        self.theSession.AddMap(self.aMap)
        self.aMap = None

    def start_projection(self, name, qname, attrs):
        self.ProjectionName = self.encode(attrs.get((None, 'name'), None))
        self.ProjectionParams = [ ]

    def end_projection(self, name, qname):
        if self.aLayer is not None:
            obj = self.aLayer
        elif self.aMap is not None:
            obj = self.aMap
        else:
            assert False, "projection tag out of context"
            pass

        obj.SetProjection(
            Projection(self.ProjectionParams, self.ProjectionName))

    def start_parameter(self, name, qname, attrs):
        s = attrs.get((None, 'value'))
        s = str(s) # we can't handle unicode in proj
        self.ProjectionParams.append(s)

    def start_layer(self, name, qname, attrs, layer_class = Layer):
        """Start a layer

        Instantiate a layer of class layer_class from the attributes in
        attrs which may be a dictionary as well as the normal SAX attrs
        object and bind it to self.aLayer.
        """
        title = self.encode(attrs.get((None, 'title'), ""))
        filename = attrs.get((None, 'filename'), "")
        filename = os.path.join(self.GetDirectory(), filename)
        filename = self.encode(filename)
        visible  = self.encode(attrs.get((None, 'visible'), "true")) != "false"
        fill = parse_color(attrs.get((None, 'fill'), "None"))
        stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
        stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
        if attrs.has_key((None, "shapestore")):
            store = self.idmap[attrs[(None, "shapestore")]]
        else:
            store = self.theSession.OpenShapefile(filename)
        self.aLayer = layer_class(title, store,
                                  fill = fill, stroke = stroke,
                                  lineWidth = stroke_width,
                                  visible = visible)

    def end_layer(self, name, qname):
        self.aMap.AddLayer(self.aLayer)
        self.aLayer = None

    def start_rasterlayer(self, name, qname, attrs, layer_class = RasterLayer):
        title = self.encode(attrs.get((None, 'title'), ""))
        filename = attrs.get((None, 'filename'), "")
        filename = os.path.join(self.GetDirectory(), filename)
        filename = self.encode(filename)
        visible  = self.encode(attrs.get((None, 'visible'), "true")) != "false"

        self.aLayer = layer_class(title, filename, visible = visible)

    def end_rasterlayer(self, name, qname):
        self.aMap.AddLayer(self.aLayer)
        self.aLayer = None

    def start_classification(self, name, qname, attrs):
        field = attrs.get((None, 'field'), None)

        fieldType = attrs.get((None, 'field_type'), None)
        dbFieldType = self.aLayer.GetFieldType(field)

        if fieldType != dbFieldType:
            raise ValueError(_("xml field type differs from database!"))

        # setup conversion routines depending on the kind of data
        # we will be seeing later on
        if fieldType == FIELDTYPE_STRING:
            self.conv = str
        elif fieldType == FIELDTYPE_INT:
            self.conv = lambda p: int(float(p))
        elif fieldType == FIELDTYPE_DOUBLE:
            self.conv = float

        self.aLayer.GetClassification().SetField(field)

    def end_classification(self, name, qname): 
        pass

    def start_clnull(self, name, qname, attrs):
        self.cl_group = ClassGroupDefault()
        self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
        self.cl_prop = ClassGroupProperties()

    def end_clnull(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_clpoint(self, name, qname, attrs):
        attrib_value = attrs.get((None, 'value'), "0")

        value = self.conv(attrib_value)

        self.cl_group = ClassGroupSingleton(value)
        self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
        self.cl_prop = ClassGroupProperties()


    def end_clpoint(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AppendGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_clrange(self, name, qname, attrs):

        range = attrs.get((None, 'range'), None)
        # for backward compatibility (min/max are not saved)
        min   = attrs.get((None, 'min'), None)
        max   = attrs.get((None, 'max'), None)

        try:
            if range is not None:
                self.cl_group = ClassGroupRange(Range(range))
            elif min is not None and max is not None:
                self.cl_group = ClassGroupRange(self.conv(min), self.conv(max))
            else:
                self.cl_group = ClassGroupRange(Range(None))

        except ValueError:
            raise ValueError(_("Classification range is not a number!"))

        self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
        self.cl_prop = ClassGroupProperties()


    def end_clrange(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AppendGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_cldata(self, name, qname, attrs):
        self.cl_prop.SetLineColor(
            parse_color(attrs.get((None, 'stroke'), "None")))
        self.cl_prop.SetLineWidth(
            int(attrs.get((None, 'stroke_width'), "0")))
        self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))

    def end_cldata(self, name, qname):
        pass

    def start_labellayer(self, name, qname, attrs):
        self.aLayer = self.aMap.LabelLayer()

    def start_label(self, name, qname, attrs):
        x = float(attrs[(None, 'x')])
        y = float(attrs[(None, 'y')])
        text = self.encode(attrs[(None, 'text')])
        halign = attrs[(None, 'halign')]
        valign = attrs[(None, 'valign')]
        self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)

    def characters(self, chars):
        pass


def load_session(filename):
    """Load a Thuban session from the file object file"""

    handler = SessionLoader()
    handler.read(filename)

    session = handler.theSession
    # Newly loaded session aren't modified
    session.UnsetModified()

    return session

1	bh	723	# Copyright (C) 2001, 2002, 2003 by Intevation GmbH
2	bh	6	# Authors:
3			# Jan-Oliver Wagner <[email protected]>
4	bh	267	# Bernhard Herzog <[email protected]>
5	jonathan	413	# Jonathan Coles <[email protected]>
6	bh	6	#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with GRASS for details.
9
10			"""
11			Parser for thuban session files.
12			"""
13
14			__version__ = "$Revision$"
15
16	bh	723	import string, os
17	bh	267
18			import xml.sax
19			import xml.sax.handler
20	jonathan	526	from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
21	bh	267
22	jan	374	from Thuban import _
23	jonathan	413
24	jonathan	473	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
25			FIELDTYPE_STRING
26
27	bh	6	from Thuban.Model.session import Session
28			from Thuban.Model.map import Map
29	jonathan	930	from Thuban.Model.layer import Layer, RasterLayer
30	bh	6	from Thuban.Model.color import Color
31			from Thuban.Model.proj import Projection
32	jonathan	874	from Thuban.Model.range import Range
33	jonathan	413	from Thuban.Model.classification import Classification, \
34	jonathan	439	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
35			ClassGroupProperties
36	bh	1268	from Thuban.Model.data import DerivedShapeStore, ShapefileStore
37			from Thuban.Model.table import DBFTable
38			from Thuban.Model.transientdb import TransientJoinedTable
39	bh	6
40	bh	1268	class LoadError(Exception):
41			pass
42
43	jonathan	1159	from Thuban.Model.xmlreader import XMLReader
44			import resource
45	bh	6
46	bh	267	def parse_color(color):
47			"""Return the color object for the string color.
48	bh	6
49	bh	267	Color may be either 'None' or of the form '#RRGGBB' in the usual
50			HTML color notation
51	bh	6	"""
52			color = string.strip(color)
53			if color == "None":
54	jonathan	610	result = Color.Transparent
55	bh	6	elif color[0] == '#':
56			if len(color) == 7:
57			r = string.atoi(color[1:3], 16) / 255.0
58			g = string.atoi(color[3:5], 16) / 255.0
59			b = string.atoi(color[5:7], 16) / 255.0
60			result = Color(r, g, b)
61			else:
62	jan	374	raise ValueError(_("Invalid hexadecimal color specification %s")
63	bh	6	% color)
64			else:
65	jan	374	raise ValueError(_("Invalid color specification %s") % color)
66	bh	6	return result
67
68	bh	1268	class AttrDesc:
69
70			def __init__(self, name, required = False, default = "",
71			conversion = None):
72			if not isinstance(name, tuple):
73			fullname = (None, name)
74			else:
75			fullname = name
76			name = name[1]
77			self.name = name
78			self.fullname = fullname
79			self.required = required
80			self.default = default
81			self.conversion = conversion
82
83			# set by the SessionLoader's check_attrs method
84			self.value = None
85
86
87	jonathan	706	class SessionLoader(XMLReader):
88	jonathan	694
89	jonathan	706	def __init__(self):
90	jonathan	694	"""Inititialize the Sax handler."""
91	jonathan	706	XMLReader.__init__(self)
92	jonathan	694
93			self.theSession = None
94			self.aMap = None
95			self.aLayer = None
96
97	bh	1268	# Map ids used in the thuban file to the corresponding objects
98			# in the session
99			self.idmap = {}
100	jonathan	706
101	bh	1268	dispatchers = {
102			'session' : ("start_session", "end_session"),
103			'fileshapesource': ("start_fileshapesource", None),
104			'derivedshapesource': ("start_derivedshapesource", None),
105			'filetable': ("start_filetable", None),
106			'jointable': ("start_jointable", None),
107
108			'map' : ("start_map", "end_map"),
109			'projection' : ("start_projection", "end_projection"),
110			'parameter' : ("start_parameter", None),
111			'layer' : ("start_layer", "end_layer"),
112			'rasterlayer' : ("start_rasterlayer", "end_rasterlayer"),
113			'classification': ("start_classification", "end_classification"),
114			'clnull' : ("start_clnull", "end_clnull"),
115			'clpoint' : ("start_clpoint", "end_clpoint"),
116			'clrange' : ("start_clrange", "end_clrange"),
117			'cldata' : ("start_cldata", "end_cldata"),
118			'table' : ("start_table", "end_table"),
119			'labellayer' : ("start_labellayer", None),
120			'label' : ("start_label", None)}
121
122			# all dispatchers should be used for the 0.8 namespace
123			xmlns = "http://thuban.intevation.org/dtds/thuban-0.8.dtd"
124			for key, value in dispatchers.items():
125			dispatchers[(xmlns, key)] = value
126
127			XMLReader.AddDispatchers(self, dispatchers)
128
129	bh	267	def start_session(self, name, qname, attrs):
130	bh	1268	self.theSession = Session(self.encode(attrs.get((None, 'title'),
131			None)))
132	bh	6
133	bh	267	def end_session(self, name, qname):
134			pass
135	bh	6
136	bh	1268	def check_attrs(self, element, attrs, descr):
137			"""Check and convert some of the attributes of an element
138
139			Parameters:
140			element -- The element name
141			attrs -- The attrs mapping as passed to the start_* methods
142			descr -- Sequence of attribute descriptions (AttrDesc instances)
143
144			Return a dictionary containig normalized versions of the
145			attributes described in descr. The keys of that dictionary are
146			the name attributes of the attribute descriptions. The attrs
147			dictionary will not be modified.
148
149			If the attribute is required, i.e. the 'required' attribute of
150			the descrtiption is true, but it is not in attrs, raise a
151			LoadError.
152
153			If the attribute has a default value and it is not present in
154			attrs, use that default value as the value in the returned dict.
155
156			If a conversion is specified, convert the value before putting
157			it into the returned dict. The following conversions are
158			available:
159
160			'filename' -- The attribute is a filename.
161
162			If the filename is a relative name, interpret
163			it relative to the directory containing the
164			.thuban file and make it an absolute name
165
166			'shapestore' -- The attribute is the ID of a shapestore
167			defined earlier in the .thuban file. Look it
168			up self.idmap
169
170			'table' -- The attribute is the ID of a table or shapestore
171			defined earlier in the .thuban file. Look it up
172			self.idmap. If it's the ID of a shapestore the
173			value will be the table of the shapestore.
174			"""
175			normalized = {}
176
177			for d in descr:
178			if d.required and not attrs.has_key(d.fullname):
179			pass
180			#raise LoadError("Element %s requires an attribute %r"
181			# % (element, d.name))
182			value = attrs.get(d.fullname, d.default)
183
184			if d.conversion == "shapesource":
185			if value in self.idmap:
186			value = self.idmap[value]
187			else:
188			raise LoadError("Element %s requires an already defined ID"
189			" in attribute %r"
190			% (element, d.name))
191			elif d.conversion == "table":
192			if value in self.idmap:
193			value = self.idmap[value]
194			if isinstance(value, ShapefileStore):
195			value = value.Table()
196			else:
197			raise LoadError("Element %s requires an already defined ID"
198			" in attribute %r"
199			% (element, d.name))
200			elif d.conversion == "filename":
201			value = os.path.abspath(os.path.join(self.GetDirectory(),
202			value))
203
204			normalized[d.name] = value
205			return normalized
206
207			def start_fileshapesource(self, name, qname, attrs):
208			attrs = self.check_attrs(name, attrs,
209			[AttrDesc("id", True),
210			AttrDesc("filename", True,
211			conversion = "filename"),
212			AttrDesc("filetype", True)])
213			ID = attrs["id"]
214			filename = attrs["filename"]
215			filetype = attrs["filetype"]
216			if filetype != "shapefile":
217			raise LoadError("shapesource filetype %r not supported" % filetype)
218			self.idmap[ID] = self.theSession.OpenShapefile(filename)
219
220			def start_derivedshapesource(self, name, qname, attrs):
221			attrs = self.check_attrs(name, attrs,
222			[AttrDesc("id", True),
223			AttrDesc("shapesource", True,
224			conversion = "shapesource"),
225			AttrDesc("table", True, conversion="table")])
226			self.idmap[attrs["id"]] = DerivedShapeStore(attrs["shapesource"],
227			attrs["table"])
228
229			def start_filetable(self, name, qname, attrs):
230			attrs = self.check_attrs(name, attrs,
231			[AttrDesc("id", True),
232			AttrDesc("title", True),
233			AttrDesc("filename", True,
234			conversion = "filename"),
235			AttrDesc("filetype")])
236			filetype = attrs["filetype"]
237			if filetype != "DBF":
238			raise LoadError("shapesource filetype %r not supported" % filetype)
239			table = DBFTable(attrs["filename"])
240			table.SetTitle(attrs["title"])
241			self.idmap[attrs["id"]] = self.theSession.AddTable(table)
242
243			def start_jointable(self, name, qname, attrs):
244			attrs = self.check_attrs(name, attrs,
245			[AttrDesc("id", True),
246			AttrDesc("title", True),
247			AttrDesc("left", True, conversion="table"),
248			AttrDesc("leftcolumn", True),
249			AttrDesc("right", True, conversion="table"),
250			AttrDesc("rightcolumn")])
251			table = TransientJoinedTable(self.theSession.TransientDB(),
252			attrs["left"], attrs["leftcolumn"],
253			attrs["right"], attrs["rightcolumn"])
254			table.SetTitle(attrs["title"])
255			self.idmap[attrs["id"]] = self.theSession.AddTable(table)
256
257	bh	267	def start_map(self, name, qname, attrs):
258			"""Start a map."""
259			self.aMap = Map(attrs.get((None, 'title'), None))
260
261			def end_map(self, name, qname):
262			self.theSession.AddMap(self.aMap)
263	jonathan	874	self.aMap = None
264	bh	267
265			def start_projection(self, name, qname, attrs):
266	jonathan	874	self.ProjectionName = self.encode(attrs.get((None, 'name'), None))
267	bh	267	self.ProjectionParams = [ ]
268
269			def end_projection(self, name, qname):
270	jonathan	874	if self.aLayer is not None:
271			obj = self.aLayer
272			elif self.aMap is not None:
273			obj = self.aMap
274			else:
275			assert False, "projection tag out of context"
276			pass
277
278			obj.SetProjection(
279	jonathan	744	Projection(self.ProjectionParams, self.ProjectionName))
280	bh	267
281			def start_parameter(self, name, qname, attrs):
282			s = attrs.get((None, 'value'))
283			s = str(s) # we can't handle unicode in proj
284			self.ProjectionParams.append(s)
285
286			def start_layer(self, name, qname, attrs, layer_class = Layer):
287			"""Start a layer
288
289			Instantiate a layer of class layer_class from the attributes in
290			attrs which may be a dictionary as well as the normal SAX attrs
291			object and bind it to self.aLayer.
292			"""
293	jonathan	874	title = self.encode(attrs.get((None, 'title'), ""))
294	bh	267	filename = attrs.get((None, 'filename'), "")
295	jonathan	694	filename = os.path.join(self.GetDirectory(), filename)
296	jonathan	930	filename = self.encode(filename)
297			visible = self.encode(attrs.get((None, 'visible'), "true")) != "false"
298	bh	267	fill = parse_color(attrs.get((None, 'fill'), "None"))
299			stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
300			stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
301	bh	1268	if attrs.has_key((None, "shapestore")):
302			store = self.idmap[attrs[(None, "shapestore")]]
303			else:
304			store = self.theSession.OpenShapefile(filename)
305			self.aLayer = layer_class(title, store,
306	bh	723	fill = fill, stroke = stroke,
307	jonathan	772	lineWidth = stroke_width,
308	jonathan	930	visible = visible)
309	bh	267
310			def end_layer(self, name, qname):
311			self.aMap.AddLayer(self.aLayer)
312	jonathan	874	self.aLayer = None
313	bh	267
314	jonathan	930	def start_rasterlayer(self, name, qname, attrs, layer_class = RasterLayer):
315			title = self.encode(attrs.get((None, 'title'), ""))
316			filename = attrs.get((None, 'filename'), "")
317			filename = os.path.join(self.GetDirectory(), filename)
318			filename = self.encode(filename)
319			visible = self.encode(attrs.get((None, 'visible'), "true")) != "false"
320
321			self.aLayer = layer_class(title, filename, visible = visible)
322
323			def end_rasterlayer(self, name, qname):
324			self.aMap.AddLayer(self.aLayer)
325			self.aLayer = None
326
327	jonathan	365	def start_classification(self, name, qname, attrs):
328	jonathan	465	field = attrs.get((None, 'field'), None)
329
330			fieldType = attrs.get((None, 'field_type'), None)
331			dbFieldType = self.aLayer.GetFieldType(field)
332
333			if fieldType != dbFieldType:
334			raise ValueError(_("xml field type differs from database!"))
335
336			# setup conversion routines depending on the kind of data
337			# we will be seeing later on
338			if fieldType == FIELDTYPE_STRING:
339			self.conv = str
340			elif fieldType == FIELDTYPE_INT:
341			self.conv = lambda p: int(float(p))
342			elif fieldType == FIELDTYPE_DOUBLE:
343			self.conv = float
344
345			self.aLayer.GetClassification().SetField(field)
346
347	jonathan	365	def end_classification(self, name, qname):
348			pass
349
350			def start_clnull(self, name, qname, attrs):
351	jonathan	439	self.cl_group = ClassGroupDefault()
352	jonathan	874	self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
353	jonathan	439	self.cl_prop = ClassGroupProperties()
354	jonathan	365
355			def end_clnull(self, name, qname):
356	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
357			self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
358			del self.cl_group, self.cl_prop
359	jonathan	365
360			def start_clpoint(self, name, qname, attrs):
361			attrib_value = attrs.get((None, 'value'), "0")
362
363	jonathan	465	value = self.conv(attrib_value)
364
365	jonathan	439	self.cl_group = ClassGroupSingleton(value)
366	jonathan	874	self.cl_group.SetLabel(self.encode(attrs.get((None, 'label'), "")))
367	jonathan	439	self.cl_prop = ClassGroupProperties()
368	jonathan	413
369	jonathan	365
370			def end_clpoint(self, name, qname):
371	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
372	jonathan	614	self.aLayer.GetClassification().AppendGroup(self.cl_group)
373	jonathan	439	del self.cl_group, self.cl_prop
374	jonathan	365
375			def start_clrange(self, name, qname, attrs):
376
377	jonathan	874	range = attrs.get((None, 'range'), None)
378			# for backward compatibility (min/max are not saved)
379			min = attrs.get((None, 'min'), None)
380			max = attrs.get((None, 'max'), None)
381
382	jonathan	365	try:
383	jonathan	874	if range is not None:
384			self.cl_group = ClassGroupRange(Range(range))
385			elif min is not None and max is not None:
386			self.cl_group = ClassGroupRange(self.conv(min), self.conv(max))
387			else:
388			self.cl_group = ClassGroupRange(Range(None))
389
390	jonathan	365	except ValueError:
391	jan	374	raise ValueError(_("Classification range is not a number!"))
392	jonathan	365
393	jonathan	439	self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
394			self.cl_prop = ClassGroupProperties()
395	jonathan	413
396	jonathan	365
397			def end_clrange(self, name, qname):
398	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
399	jonathan	614	self.aLayer.GetClassification().AppendGroup(self.cl_group)
400	jonathan	439	del self.cl_group, self.cl_prop
401	jonathan	365
402			def start_cldata(self, name, qname, attrs):
403	jonathan	465	self.cl_prop.SetLineColor(
404			parse_color(attrs.get((None, 'stroke'), "None")))
405			self.cl_prop.SetLineWidth(
406	jonathan	390	int(attrs.get((None, 'stroke_width'), "0")))
407	jonathan	439	self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
408	jonathan	365
409			def end_cldata(self, name, qname):
410			pass
411
412	bh	267	def start_labellayer(self, name, qname, attrs):
413			self.aLayer = self.aMap.LabelLayer()
414
415			def start_label(self, name, qname, attrs):
416			x = float(attrs[(None, 'x')])
417			y = float(attrs[(None, 'y')])
418	jonathan	874	text = self.encode(attrs[(None, 'text')])
419	bh	267	halign = attrs[(None, 'halign')]
420			valign = attrs[(None, 'valign')]
421			self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)
422
423			def characters(self, chars):
424			pass
425
426
427	jonathan	694	def load_session(filename):
428			"""Load a Thuban session from the file object file"""
429
430	jonathan	706	handler = SessionLoader()
431			handler.read(filename)
432	jonathan	694
433	bh	6	session = handler.theSession
434			# Newly loaded session aren't modified
435			session.UnsetModified()
436
437			return session
438
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision