Thuban/Model/save.py

# Copyright (c) 2001, 2002, 2003, 2004 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 Thuban for details.

"""
Functions to save a session to a file
"""

__version__ = "$Revision$"

import os

import Thuban.Lib.fileutil

from Thuban.Model.layer import Layer, RasterLayer

from Thuban.Model.classification import \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap
from Thuban.Model.transientdb import AutoTransientTable, TransientJoinedTable
from Thuban.Model.table import DBFTable, FIELDTYPE_STRING
from Thuban.Model.data import DerivedShapeStore, ShapefileStore

from Thuban.Model.xmlwriter import XMLWriter
from postgisdb import PostGISConnection, PostGISShapeStore

def relative_filename(dir, filename):
    """Return a filename relative to dir for the absolute file name absname.

    This is almost the same as the function in fileutil, except that dir
    can be an empty string in which case filename will be returned
    unchanged.
    """
    if dir:
        return Thuban.Lib.fileutil.relative_filename(dir, filename)
    else:
        return filename


def unify_filename(filename):
    """Return a 'unified' version of filename

    The .thuban files should be as platform independent as possible.
    Since they must contain filenames the filenames have to unified. We
    unify on unix-like filenames for now, which means we do nothing on a
    posix system and simply replace backslashes with slashes on windows
    """
    if os.name == "posix":
        return filename
    elif os.name == "nt":
        return "/".join(filename.split("\\"))
    else:
        raise RuntimeError("Unsupported platform for unify_filename: %s"
                           % os.name)

def sort_data_stores(stores):
    """Return a topologically sorted version of the sequence of data containers

    The list is sorted so that data containers that depend on other data
    containers have higher indexes than the containers they depend on.
    """
    if not stores:
        return []
    processed = {}
    result = []
    todo = stores[:]
    while todo:
        # It doesn't really matter which if the items of todo is
        # processed next, but if we take the first one, the order is
        # preserved to some degree which makes writing some of the test
        # cases easier.
        container = todo.pop(0)
        if id(container) in processed:
            continue
        deps = [dep for dep in container.Dependencies()
                    if id(dep) not in processed]
        if deps:
            todo.append(container)
            todo.extend(deps)
        else:
            result.append(container)
            processed[id(container)] = 1
    return result


class SessionSaver(XMLWriter):

    """Class to serialize a session into an XML file.

    Applications built on top of Thuban may derive from this class and
    override or extend the methods to save additional information. This
    additional information should take the form of additional attributes
    or elements whose names are prefixed with a namespace. To define a
    namespace derived classes should extend the write_session method to
    pass the namespaces to the default implementation.
    """


    def __init__(self, session):
        XMLWriter.__init__(self)
        self.session = session
        # Map object ids to the ids used in the thuban files
        self.idmap = {}

    def get_id(self, obj):
        """Return the id used in the thuban file for the object obj"""
        return self.idmap.get(id(obj))

    def define_id(self, obj, value = None):
        if value is None:
            value = "D" + str(id(obj))
        self.idmap[id(obj)] = value
        return value

    def has_id(self, obj):
        return self.idmap.has_key(id(obj))

    def prepare_filename(self, filename):
        """Return the string to use when writing filename to the thuban file

        The returned string is a unified version (only slashes as
        directory separators, see unify_filename) of filename expressed
        relative to the directory the .thuban file is written to.
        """
        return unify_filename(relative_filename(self.dir, filename))

    def write(self, file_or_filename):
        XMLWriter.write(self, file_or_filename)

        self.write_header("session", "thuban-1.1.dtd")
        self.write_session(self.session)
        self.close()

    def write_session(self, session, attrs = None, namespaces = ()):
        """Write the session and its contents

        By default, write a session element with the title attribute and
        call write_map for each map contained in the session.

        The optional argument attrs is for additional attributes and, if
        given, should be a mapping from attribute names to attribute
        values. The values should not be XML-escaped yet.

        The optional argument namespaces, if given, should be a sequence
        of (name, URI) pairs. The namespaces are written as namespace
        attributes into the session element. This is mainly useful for
        derived classes that need to store additional information in a
        thuban session file.
        """
        if attrs is None:
            attrs = {}
        attrs["title"] = session.title
        for name, uri in namespaces:
            attrs["xmlns:" + name] = uri
        # default name space
        attrs["xmlns"] = \
               "http://thuban.intevation.org/dtds/thuban-1.1-dev.dtd"
        self.open_element("session", attrs)
        self.write_db_connections(session)
        self.write_data_containers(session)
        for map in session.Maps():
            self.write_map(map)
        self.close_element("session")

    def write_db_connections(self, session):
        for conn in session.DBConnections():
            if isinstance(conn, PostGISConnection):
                self.write_element("dbconnection",
                                   {"id": self.define_id(conn),
                                    "dbtype": "postgis",
                                    "host": conn.host,
                                    "port": conn.port,
                                    "user": conn.user,
                                    "dbname": conn.dbname})
            else:
                raise ValueError("Can't handle db connection %r" % conn)

    def write_data_containers(self, session):
        containers = sort_data_stores(session.DataContainers())
        for container in containers:
            if isinstance(container, AutoTransientTable):
                # AutoTransientTable instances are invisible in the
                # thuban files. They're only used internally. To make
                # sure that containers depending on AutoTransientTable
                # instances refer to the right real containers we give
                # the AutoTransientTable instances the same id as the
                # source they depend on.
                self.define_id(container,
                               self.get_id(container.Dependencies()[0]))
                continue

            idvalue = self.define_id(container)
            if isinstance(container, ShapefileStore):
                self.define_id(container.Table(), idvalue)
                filename = self.prepare_filename(container.FileName())
                self.write_element("fileshapesource",
                                   {"id": idvalue, "filename": filename,
                                    "filetype": "shapefile"})
            elif isinstance(container, DerivedShapeStore):
                shapesource, table = container.Dependencies()
                self.write_element("derivedshapesource",
                                   {"id": idvalue,
                                    "shapesource": self.get_id(shapesource),
                                    "table": self.get_id(table)})
            elif isinstance(container, PostGISShapeStore):
                conn = container.DBConnection()
                self.write_element("dbshapesource",
                                   {"id": idvalue,
                                    "dbconn": self.get_id(conn),
                                    "tablename": container.TableName(),
                                    "id_column": container.IDColumn().name,
                                    "geometry_column":
                                      container.GeometryColumn().name,
                                    })
            elif isinstance(container, DBFTable):
                filename = self.prepare_filename(container.FileName())
                self.write_element("filetable",
                                   {"id": idvalue,
                                    "title": container.Title(),
                                    "filename": filename,
                                    "filetype": "DBF"})
            elif isinstance(container, TransientJoinedTable):
                left, right = container.Dependencies()
                left_field = container.left_field
                right_field = container.right_field
                self.write_element("jointable",
                                   {"id": idvalue,
                                    "title": container.Title(),
                                    "right": self.get_id(right),
                                    "rightcolumn": right_field,
                                    "left": self.get_id(left),
                                    "leftcolumn": left_field,
                                    "jointype": container.JoinType()})
            else:
                raise ValueError("Can't handle container %r" % container)


    def write_map(self, map):
        """Write the map and its contents.

        By default, write a map element element with the title
        attribute, call write_projection to write the projection
        element, call write_layer for each layer contained in the map
        and finally call write_label_layer to write the label layer.
        """
        self.open_element('map title="%s"' % self.encode(map.title))
        self.write_projection(map.projection)
        for layer in map.Layers():
            self.write_layer(layer)
        self.write_label_layer(map.LabelLayer())
        self.close_element('map')

    def write_projection(self, projection):
        """Write the projection.
        """
        if projection and len(projection.params) > 0:
            attrs = {"name": projection.GetName()}
            epsg = projection.EPSGCode()
            if epsg is not None:
                attrs["epsg"] = epsg
            self.open_element("projection", attrs)
            for param in projection.params:
                self.write_element('parameter value="%s"' % 
                                   self.encode(param))
            self.close_element("projection")

    def write_layer(self, layer, attrs = None):
        """Write the layer.

        The optional argument attrs is for additional attributes and, if
        given, should be a mapping from attribute names to attribute
        values. The values should not be XML-escaped yet.
        """

        if attrs is None:
            attrs = {}

        attrs["title"]   = layer.title
        attrs["visible"] = ("false", "true")[int(layer.Visible())]

        if isinstance(layer, Layer):
            attrs["shapestore"]   = self.get_id(layer.ShapeStore())

            lc = layer.GetClassification()
            attrs["stroke"] = lc.GetDefaultLineColor().hex()
            attrs["stroke_width"] = str(lc.GetDefaultLineWidth())
            attrs["fill"] = lc.GetDefaultFill().hex()

            self.open_element("layer", attrs)
            self.write_projection(layer.GetProjection())
            self.write_classification(layer)
            self.close_element("layer")
        elif isinstance(layer, RasterLayer):
            attrs["filename"] = self.prepare_filename(layer.filename)
            self.open_element("rasterlayer", attrs)
            self.write_projection(layer.GetProjection())
            self.close_element("rasterlayer")

    def write_classification(self, layer, attrs = None):
        """Write Classification information."""

        if attrs is None:
            attrs = {}

        lc = layer.GetClassification()

        field = layer.GetClassificationColumn()

        #
        # there isn't a classification of anything so do nothing
        #
        if field is None: return

        attrs["field"] = field
        attrs["field_type"] = str(layer.GetFieldType(field))
        self.open_element("classification", attrs)

        for g in lc:
            if isinstance(g, ClassGroupDefault):
                open_el  = 'clnull label="%s"' % self.encode(g.GetLabel())
                close_el = 'clnull'
            elif isinstance(g, ClassGroupSingleton):
                if layer.GetFieldType(field) == FIELDTYPE_STRING:
                    value = self.encode(g.GetValue())
                else:
                    value = str(g.GetValue())
                open_el  = 'clpoint label="%s" value="%s"' \
                           % (self.encode(g.GetLabel()), value)
                close_el = 'clpoint'
            elif isinstance(g, ClassGroupRange):
                open_el  = 'clrange label="%s" range="%s"' \
                          % (self.encode(g.GetLabel()), str(g.GetRange()))
                close_el = 'clrange'
            else:
                assert False, _("Unsupported group type in classification")
                continue

            data = g.GetProperties()
            dict = {'stroke'      : data.GetLineColor().hex(),
                    'stroke_width': str(data.GetLineWidth()),
                    'fill'        : data.GetFill().hex()}

            self.open_element(open_el)
            self.write_element("cldata", dict)
            self.close_element(close_el)

        self.close_element("classification")

    def write_label_layer(self, layer):
        """Write the label layer.
        """
        labels = layer.Labels()
        if labels:
            self.open_element('labellayer')
            for label in labels:
                self.write_element(('label x="%g" y="%g" text="%s"'
                                    ' halign="%s" valign="%s"')
                                % (label.x, label.y, 
                                   self.encode(label.text), 
                                   label.halign,
                                   label.valign))
            self.close_element('labellayer')


def save_session(session, file, saver_class = None):
    """Save the session session to a file.

    The file argument may either be a filename or an open file object.

    The optional argument saver_class is the class to use to serialize
    the session. By default or if it's None, the saver class will be
    SessionSaver.

    If writing the session is successful call the session's
    UnsetModified method
    """
    if saver_class is None:
        saver_class = SessionSaver
    saver = saver_class(session)
    saver.write(file)

    # after a successful save consider the session unmodified.
    session.UnsetModified()
1	bh	2104	# Copyright (c) 2001, 2002, 2003, 2004 by Intevation GmbH
2	bh	6	# Authors:
3			# Jan-Oliver Wagner <[email protected]>
4			# Bernhard Herzog <[email protected]>
5	jonathan	414	# Jonathan Coles <[email protected]>
6	bh	6	#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with Thuban for details.
9
10			"""
11			Functions to save a session to a file
12			"""
13
14			__version__ = "$Revision$"
15
16			import os
17
18	bh	201	import Thuban.Lib.fileutil
19	bh	6
20	jonathan	932	from Thuban.Model.layer import Layer, RasterLayer
21
22	jonathan	876	from Thuban.Model.classification import \
23			ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap
24	bh	1268	from Thuban.Model.transientdb import AutoTransientTable, TransientJoinedTable
25	bh	1417	from Thuban.Model.table import DBFTable, FIELDTYPE_STRING
26	bh	1268	from Thuban.Model.data import DerivedShapeStore, ShapefileStore
27	jonathan	429
28	jonathan	1160	from Thuban.Model.xmlwriter import XMLWriter
29	bh	1638	from postgisdb import PostGISConnection, PostGISShapeStore
30	jonathan	366
31	bh	201	def relative_filename(dir, filename):
32			"""Return a filename relative to dir for the absolute file name absname.
33
34			This is almost the same as the function in fileutil, except that dir
35			can be an empty string in which case filename will be returned
36			unchanged.
37			"""
38			if dir:
39			return Thuban.Lib.fileutil.relative_filename(dir, filename)
40			else:
41			return filename
42
43	bh	1268
44	bh	1989	def unify_filename(filename):
45			"""Return a 'unified' version of filename
46
47			The .thuban files should be as platform independent as possible.
48			Since they must contain filenames the filenames have to unified. We
49			unify on unix-like filenames for now, which means we do nothing on a
50			posix system and simply replace backslashes with slashes on windows
51			"""
52			if os.name == "posix":
53			return filename
54			elif os.name == "nt":
55			return "/".join(filename.split("\\"))
56			else:
57			raise RuntimeError("Unsupported platform for unify_filename: %s"
58			% os.name)
59
60	bh	1268	def sort_data_stores(stores):
61			"""Return a topologically sorted version of the sequence of data containers
62
63			The list is sorted so that data containers that depend on other data
64			containers have higher indexes than the containers they depend on.
65			"""
66			if not stores:
67			return []
68			processed = {}
69			result = []
70			todo = stores[:]
71			while todo:
72			# It doesn't really matter which if the items of todo is
73			# processed next, but if we take the first one, the order is
74			# preserved to some degree which makes writing some of the test
75			# cases easier.
76			container = todo.pop(0)
77			if id(container) in processed:
78			continue
79			deps = [dep for dep in container.Dependencies()
80			if id(dep) not in processed]
81			if deps:
82			todo.append(container)
83			todo.extend(deps)
84			else:
85			result.append(container)
86			processed[id(container)] = 1
87			return result
88
89
90	jonathan	710	class SessionSaver(XMLWriter):
91	bh	268
92	jonathan	697	"""Class to serialize a session into an XML file.
93
94			Applications built on top of Thuban may derive from this class and
95			override or extend the methods to save additional information. This
96			additional information should take the form of additional attributes
97			or elements whose names are prefixed with a namespace. To define a
98			namespace derived classes should extend the write_session method to
99			pass the namespaces to the default implementation.
100			"""
101
102
103			def __init__(self, session):
104	jonathan	710	XMLWriter.__init__(self)
105	jonathan	697	self.session = session
106	bh	1268	# Map object ids to the ids used in the thuban files
107			self.idmap = {}
108	jonathan	697
109	bh	1268	def get_id(self, obj):
110			"""Return the id used in the thuban file for the object obj"""
111			return self.idmap.get(id(obj))
112
113			def define_id(self, obj, value = None):
114			if value is None:
115			value = "D" + str(id(obj))
116			self.idmap[id(obj)] = value
117			return value
118
119			def has_id(self, obj):
120			return self.idmap.has_key(id(obj))
121
122	bh	1989	def prepare_filename(self, filename):
123			"""Return the string to use when writing filename to the thuban file
124
125			The returned string is a unified version (only slashes as
126			directory separators, see unify_filename) of filename expressed
127			relative to the directory the .thuban file is written to.
128			"""
129			return unify_filename(relative_filename(self.dir, filename))
130
131	jonathan	697	def write(self, file_or_filename):
132	jonathan	710	XMLWriter.write(self, file_or_filename)
133	jonathan	697
134	bh	2104	self.write_header("session", "thuban-1.1.dtd")
135	jonathan	697	self.write_session(self.session)
136			self.close()
137
138	bh	268	def write_session(self, session, attrs = None, namespaces = ()):
139			"""Write the session and its contents
140
141			By default, write a session element with the title attribute and
142			call write_map for each map contained in the session.
143
144			The optional argument attrs is for additional attributes and, if
145			given, should be a mapping from attribute names to attribute
146			values. The values should not be XML-escaped yet.
147
148			The optional argument namespaces, if given, should be a sequence
149			of (name, URI) pairs. The namespaces are written as namespace
150			attributes into the session element. This is mainly useful for
151			derived classes that need to store additional information in a
152			thuban session file.
153			"""
154			if attrs is None:
155			attrs = {}
156			attrs["title"] = session.title
157			for name, uri in namespaces:
158			attrs["xmlns:" + name] = uri
159	bh	1268	# default name space
160			attrs["xmlns"] = \
161	bh	2104	"http://thuban.intevation.org/dtds/thuban-1.1-dev.dtd"
162	jonathan	366	self.open_element("session", attrs)
163	bh	1638	self.write_db_connections(session)
164	bh	1268	self.write_data_containers(session)
165	bh	268	for map in session.Maps():
166			self.write_map(map)
167	jonathan	366	self.close_element("session")
168	bh	268
169	bh	1638	def write_db_connections(self, session):
170			for conn in session.DBConnections():
171			if isinstance(conn, PostGISConnection):
172			self.write_element("dbconnection",
173			{"id": self.define_id(conn),
174			"dbtype": "postgis",
175			"host": conn.host,
176			"port": conn.port,
177			"user": conn.user,
178			"dbname": conn.dbname})
179			else:
180			raise ValueError("Can't handle db connection %r" % conn)
181
182	bh	1268	def write_data_containers(self, session):
183			containers = sort_data_stores(session.DataContainers())
184			for container in containers:
185			if isinstance(container, AutoTransientTable):
186			# AutoTransientTable instances are invisible in the
187			# thuban files. They're only used internally. To make
188			# sure that containers depending on AutoTransientTable
189			# instances refer to the right real containers we give
190			# the AutoTransientTable instances the same id as the
191			# source they depend on.
192			self.define_id(container,
193			self.get_id(container.Dependencies()[0]))
194			continue
195
196			idvalue = self.define_id(container)
197			if isinstance(container, ShapefileStore):
198			self.define_id(container.Table(), idvalue)
199	bh	1989	filename = self.prepare_filename(container.FileName())
200	bh	1268	self.write_element("fileshapesource",
201			{"id": idvalue, "filename": filename,
202			"filetype": "shapefile"})
203			elif isinstance(container, DerivedShapeStore):
204			shapesource, table = container.Dependencies()
205			self.write_element("derivedshapesource",
206			{"id": idvalue,
207			"shapesource": self.get_id(shapesource),
208			"table": self.get_id(table)})
209	bh	1638	elif isinstance(container, PostGISShapeStore):
210			conn = container.DBConnection()
211			self.write_element("dbshapesource",
212			{"id": idvalue,
213			"dbconn": self.get_id(conn),
214	bh	2104	"tablename": container.TableName(),
215			"id_column": container.IDColumn().name,
216			"geometry_column":
217			container.GeometryColumn().name,
218			})
219	bh	1268	elif isinstance(container, DBFTable):
220	bh	1989	filename = self.prepare_filename(container.FileName())
221	bh	1268	self.write_element("filetable",
222			{"id": idvalue,
223			"title": container.Title(),
224			"filename": filename,
225			"filetype": "DBF"})
226			elif isinstance(container, TransientJoinedTable):
227			left, right = container.Dependencies()
228			left_field = container.left_field
229			right_field = container.right_field
230			self.write_element("jointable",
231			{"id": idvalue,
232			"title": container.Title(),
233			"right": self.get_id(right),
234			"rightcolumn": right_field,
235			"left": self.get_id(left),
236	bh	1375	"leftcolumn": left_field,
237			"jointype": container.JoinType()})
238	bh	1268	else:
239			raise ValueError("Can't handle container %r" % container)
240
241
242	bh	268	def write_map(self, map):
243			"""Write the map and its contents.
244
245			By default, write a map element element with the title
246			attribute, call write_projection to write the projection
247			element, call write_layer for each layer contained in the map
248			and finally call write_label_layer to write the label layer.
249			"""
250	jonathan	876	self.open_element('map title="%s"' % self.encode(map.title))
251	bh	268	self.write_projection(map.projection)
252			for layer in map.Layers():
253			self.write_layer(layer)
254			self.write_label_layer(map.LabelLayer())
255	jonathan	366	self.close_element('map')
256	bh	6
257	bh	268	def write_projection(self, projection):
258			"""Write the projection.
259			"""
260			if projection and len(projection.params) > 0:
261	bh	1843	attrs = {"name": projection.GetName()}
262			epsg = projection.EPSGCode()
263			if epsg is not None:
264			attrs["epsg"] = epsg
265			self.open_element("projection", attrs)
266	bh	268	for param in projection.params:
267	jonathan	876	self.write_element('parameter value="%s"' %
268			self.encode(param))
269	jonathan	366	self.close_element("projection")
270	bh	268
271			def write_layer(self, layer, attrs = None):
272			"""Write the layer.
273
274			The optional argument attrs is for additional attributes and, if
275			given, should be a mapping from attribute names to attribute
276			values. The values should not be XML-escaped yet.
277			"""
278	jonathan	391
279	bh	268	if attrs is None:
280			attrs = {}
281	jonathan	429
282	jonathan	1251	attrs["title"] = layer.title
283			attrs["visible"] = ("false", "true")[int(layer.Visible())]
284	bh	268
285	jonathan	932	if isinstance(layer, Layer):
286	bh	1268	attrs["shapestore"] = self.get_id(layer.ShapeStore())
287	jonathan	740
288	jonathan	932	lc = layer.GetClassification()
289	bh	1268	attrs["stroke"] = lc.GetDefaultLineColor().hex()
290	jonathan	932	attrs["stroke_width"] = str(lc.GetDefaultLineWidth())
291	bh	1268	attrs["fill"] = lc.GetDefaultFill().hex()
292	jonathan	740
293	jonathan	932	self.open_element("layer", attrs)
294			self.write_projection(layer.GetProjection())
295			self.write_classification(layer)
296			self.close_element("layer")
297			elif isinstance(layer, RasterLayer):
298	bh	1989	attrs["filename"] = self.prepare_filename(layer.filename)
299	jonathan	932	self.open_element("rasterlayer", attrs)
300			self.write_projection(layer.GetProjection())
301			self.close_element("rasterlayer")
302
303	jonathan	366	def write_classification(self, layer, attrs = None):
304	jonathan	1251	"""Write Classification information."""
305
306	jonathan	366	if attrs is None:
307			attrs = {}
308
309	jonathan	414	lc = layer.GetClassification()
310	jonathan	366
311	bh	1452	field = layer.GetClassificationColumn()
312
313	jonathan	366	#
314	jonathan	1251	# there isn't a classification of anything so do nothing
315	jonathan	366	#
316			if field is None: return
317
318			attrs["field"] = field
319	jonathan	1430	attrs["field_type"] = str(layer.GetFieldType(field))
320	jonathan	366	self.open_element("classification", attrs)
321
322	jonathan	1251	for g in lc:
323			if isinstance(g, ClassGroupDefault):
324			open_el = 'clnull label="%s"' % self.encode(g.GetLabel())
325			close_el = 'clnull'
326	bh	1417	elif isinstance(g, ClassGroupSingleton):
327	jonathan	1430	if layer.GetFieldType(field) == FIELDTYPE_STRING:
328	bh	1417	value = self.encode(g.GetValue())
329			else:
330			value = str(g.GetValue())
331	jonathan	1251	open_el = 'clpoint label="%s" value="%s"' \
332	bh	1417	% (self.encode(g.GetLabel()), value)
333	jonathan	1251	close_el = 'clpoint'
334			elif isinstance(g, ClassGroupRange):
335			open_el = 'clrange label="%s" range="%s"' \
336			% (self.encode(g.GetLabel()), str(g.GetRange()))
337			close_el = 'clrange'
338			else:
339			assert False, _("Unsupported group type in classification")
340			continue
341	jonathan	429
342	jonathan	1251	data = g.GetProperties()
343			dict = {'stroke' : data.GetLineColor().hex(),
344			'stroke_width': str(data.GetLineWidth()),
345			'fill' : data.GetFill().hex()}
346	jonathan	429
347	jonathan	1251	self.open_element(open_el)
348			self.write_element("cldata", dict)
349			self.close_element(close_el)
350	jonathan	366
351			self.close_element("classification")
352
353	bh	268	def write_label_layer(self, layer):
354			"""Write the label layer.
355			"""
356			labels = layer.Labels()
357	bh	6	if labels:
358	jonathan	366	self.open_element('labellayer')
359	bh	6	for label in labels:
360	jonathan	366	self.write_element(('label x="%g" y="%g" text="%s"'
361			' halign="%s" valign="%s"')
362	jonathan	876	% (label.x, label.y,
363			self.encode(label.text),
364			label.halign,
365	bh	268	label.valign))
366	jonathan	366	self.close_element('labellayer')
367	bh	6
368	bh	268
369
370			def save_session(session, file, saver_class = None):
371			"""Save the session session to a file.
372
373			The file argument may either be a filename or an open file object.
374
375			The optional argument saver_class is the class to use to serialize
376			the session. By default or if it's None, the saver class will be
377	jonathan	697	SessionSaver.
378	bh	268
379			If writing the session is successful call the session's
380			UnsetModified method
381			"""
382			if saver_class is None:
383	jonathan	697	saver_class = SessionSaver
384	bh	268	saver = saver_class(session)
385			saver.write(file)
386
387	bh	6	# after a successful save consider the session unmodified.
388			session.UnsetModified()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision