Thuban/Model/save.py

# Copyright (c) 2001-2004 by Intevation GmbH
# Authors:
# Jan-Oliver Wagner <[email protected]> (2004)
# Bernhard Herzog <[email protected]> (2001-2004)
# Jonathan Coles <[email protected]> (2003)
# Frank Koormann <[email protected]> (2003)
#
# 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$"
# $Source$
# $Id$

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, \
                              SHAPETYPE_POINT

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

def bool2str(b):
    if b: return "true"
    else: return "false"

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"] = bool2str(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()}

            # only for point layers write the size attribute
            if layer.ShapeType() == SHAPETYPE_POINT:
                dict['size'] =  str(data.GetSize())

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