Thuban/Model/save.py

# Copyright (c) 2001, 2002 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$"

# fix for people using python2.1
from __future__ import nested_scopes

import os
import string

import Thuban.Lib.fileutil

from Thuban.Model.color import Color 

from Thuban.Model.classification import *

#
# one level of indention
#
TAB = "    "

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 escape(data):
    """Escape &, \", ', <, and > in a string of data.
    """
    data = string.replace(data, "&", "&amp;")
    data = string.replace(data, "<", "&lt;")
    data = string.replace(data, ">", "&gt;")
    data = string.replace(data, '"', "&quot;")
    data = string.replace(data, "'", "&apos;")
    return data

class Saver:

    """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 additinal 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):
        self.session = session

    def write(self, file_or_filename):
        """Write the session to a file.

        The argument may be either a file object or a filename. If it's
        a filename, the file will be opened for writing. Files of
        shapefiles will be stored as filenames relative to the directory
        the file is stored in (as given by os.path.dirname(filename)) if
        they have a common parent directory other than the root
        directory.

        If the argument is a file object (which is determined by the
        presence of a write method) all filenames will be absolut
        filenames.
        """

        # keep track of how many levels of indentation to write
        self.indent_level = 0 
        # track whether an element is currently open. see open_element().
        self.element_open = 0

        if hasattr(file_or_filename, "write"):
            # it's a file object
            self.file = file_or_filename
            self.dir = ""
        else:
            filename = file_or_filename
            self.dir = os.path.dirname(filename)
            self.file = open(filename, 'w')
        self.write_header()
        self.write_session(self.session)

        assert(self.indent_level == 0)

    def write_attribs(self, attrs):
        for name, value in attrs.items():
            self.file.write(' %s="%s"' % (escape(name), escape(value)))
    
    def open_element(self, element, attrs = {}):

        #
        # we note when an element is opened so that if two open_element()
        # calls are made successively we can end the currently open
        # tag and will later write a proper close tag. otherwise,
        # if a close_element() call is made directly after an open_element()
        # call we will close the tag with a />
        #
        if self.element_open == 1:
            self.file.write(">\n")

        self.element_open = 1

        # Helper function to write an element open tag with attributes
        self.file.write("%s<%s" % (TAB*self.indent_level, element))
        self.write_attribs(attrs)

        self.indent_level += 1

    def close_element(self, element):
        self.indent_level -= 1
        assert(self.indent_level >= 0)

        # see open_element() for an explanation
        if self.element_open == 1:
            self.element_open = 0
            self.file.write("/>\n")
        else:
            self.file.write("%s</%s>\n" % (TAB*self.indent_level, element))

    def write_element(self, element, attrs = {}):
        """write an element that won't need a closing tag"""
        self.open_element(element, attrs)
        self.close_element(element)

    def write_header(self):
        """Write the XML header"""
        self.file.write('<?xml version="1.0" encoding="UTF-8"?>\n')
        self.file.write('<!DOCTYPE session SYSTEM "thuban.dtd">\n')

    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
        self.open_element("session", attrs)
        for map in session.Maps():
            self.write_map(map)
        self.close_element("session")

    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.
        """
        write = self.file.write
        self.open_element('map title="%s"' % escape(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:
            self.open_element("projection")
            for param in projection.params:
                self.write_element('parameter value="%s"' % escape(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.
        """
        lc = layer.GetClassification()

        if attrs is None:
            attrs = {}

        attrs["title"]        = layer.title
        attrs["filename"]     = relative_filename(self.dir, layer.filename)
        attrs["stroke"]       = lc.GetDefaultStroke().hex()
        attrs["stroke_width"] = str(lc.GetDefaultStrokeWidth())
        attrs["fill"]         = lc.GetDefaultFill().hex()

        self.open_element("layer", attrs)
        self.write_classification(layer)
        self.close_element("layer")

    def write_classification(self, layer, attrs = None):
        if attrs is None:
            attrs = {}

        lc = layer.GetClassification()

        field = lc.GetField()
 
        #
        # there isn't a classification of anything 
        # so don't do anything
        #
        if field is None: return

        attrs["field"] = field
        self.open_element("classification", attrs)


#       self.open_element("clnull")
#       write_class_data(lc.GetDefaultData())
#       self.close_element("clnull")
            
        # just playing now with lambdas and dictionaries

        types = [[lambda p: 'clnull', 
                  lambda p: 'clnull'],
                 [lambda p: 'clpoint value="%s"' % 
                             str(p.GetValue()),
                  lambda p: 'clpoint'],
                 [lambda p: 'clrange min="%s" max="%s"' % 
                             (str(p.GetMin()), 
                              (str(p.GetMax()))),
                  lambda p: 'clrange']]

        def write_class_group(group):
            type = -1
            if isinstance(group, ClassGroupDefault): type = 0
            elif isinstance(group, ClassGroupSingleton): type = 1
            elif isinstance(group, ClassGroupRange): type = 2
            elif isinstance(group, ClassGroupMap):   type = 3
            assert(type >= 0)

            if type <= 2: 
                data = group.GetProperties()
                dict = {'stroke'      : data.GetStroke().hex(),
                        'stroke_width': str(data.GetStrokeWidth()),
                        'fill'        : data.GetFill().hex()}

                self.open_element(types[type][0](group))
                self.write_element("cldata", dict)
                self.close_element(types[type][1](group))
            else: pass # XXX: we need to handle maps

        for i in lc:
            write_class_group(i)

#       for i in lc:
#           t = i.GetType()
#           self.open_element(types[t][0](i))
#           write_class_data(i)
#           self.close_element(types[t][1](i))

#       for p in lc:
#           type = p.GetType()
#           if p == ClassData.DEFAULT:
#               lopen = lclose = 'clnull'
#           elif p == ClassData.POINTS:
#               lopen = 'clpoint value="%s"' % escape(str(p.GetValue()))
#               lclose = 'clpoint'
#           elif p == ClassData.RANGES:
#               lopen = 'clrange min="%s" max="%s"'
#                   % (escape(str(p.GetMin())), escape(str(p.GetMax()))))
#               lclose = 'clrange'

#           self.open_element(lopen)
#           write_class_data(p)
#           self.close_element(lclose)
            
#       if lc.points != {}:
#           for p in lc.points.values():
#               self.open_element('clpoint value="%s"' % 
#                   (escape(str(p.GetValue()))))
#               write_class_data(p)
#               self.close_element('clpoint')
#          
#       if lc.ranges != []:
#           for p in lc.ranges:
#               self.open_element('clrange min="%s" max="%s"'
#                   % (escape(str(p.GetMin())), escape(str(p.GetMax()))))
#               write_class_data(p)
#               self.close_element('clrange')

        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, 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
    Saver.

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

    # after a successful save consider the session unmodified.
    session.UnsetModified()
1	bh	74	# Copyright (c) 2001, 2002 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	jonathan	440	# fix for people using python2.1
17			from __future__ import nested_scopes
18
19	bh	6	import os
20			import string
21
22	bh	201	import Thuban.Lib.fileutil
23	bh	6
24	jonathan	366	from Thuban.Model.color import Color
25
26	jonathan	429	from Thuban.Model.classification import *
27
28	jonathan	366	#
29			# one level of indention
30			#
31			TAB = " "
32
33	bh	201	def relative_filename(dir, filename):
34			"""Return a filename relative to dir for the absolute file name absname.
35
36			This is almost the same as the function in fileutil, except that dir
37			can be an empty string in which case filename will be returned
38			unchanged.
39			"""
40			if dir:
41			return Thuban.Lib.fileutil.relative_filename(dir, filename)
42			else:
43			return filename
44
45	bh	6	def escape(data):
46			"""Escape &, \", ', <, and > in a string of data.
47			"""
48			data = string.replace(data, "&", "&")
49			data = string.replace(data, "<", "<")
50			data = string.replace(data, ">", ">")
51			data = string.replace(data, '"', """)
52			data = string.replace(data, "'", "'")
53			return data
54
55	bh	268	class Saver:
56
57			"""Class to serialize a session into an XML file.
58
59			Applications built on top of Thuban may derive from this class and
60			override or extend the methods to save additinal information. This
61			additional information should take the form of additional attributes
62			or elements whose names are prefixed with a namespace. To define a
63			namespace derived classes should extend the write_session method to
64			pass the namespaces to the default implementation.
65			"""
66
67	jonathan	366
68	bh	268	def __init__(self, session):
69			self.session = session
70
71			def write(self, file_or_filename):
72			"""Write the session to a file.
73
74			The argument may be either a file object or a filename. If it's
75			a filename, the file will be opened for writing. Files of
76			shapefiles will be stored as filenames relative to the directory
77			the file is stored in (as given by os.path.dirname(filename)) if
78			they have a common parent directory other than the root
79			directory.
80
81			If the argument is a file object (which is determined by the
82			presence of a write method) all filenames will be absolut
83			filenames.
84			"""
85	jonathan	366
86	jonathan	391	# keep track of how many levels of indentation to write
87			self.indent_level = 0
88			# track whether an element is currently open. see open_element().
89			self.element_open = 0
90	jonathan	366
91	bh	268	if hasattr(file_or_filename, "write"):
92			# it's a file object
93			self.file = file_or_filename
94			self.dir = ""
95			else:
96			filename = file_or_filename
97			self.dir = os.path.dirname(filename)
98			self.file = open(filename, 'w')
99			self.write_header()
100			self.write_session(self.session)
101
102	jonathan	429	assert(self.indent_level == 0)
103	jonathan	366
104			def write_attribs(self, attrs):
105	bh	268	for name, value in attrs.items():
106	jonathan	440	self.file.write(' %s="%s"' % (escape(name), escape(value)))
107	jonathan	366
108			def open_element(self, element, attrs = {}):
109	jonathan	391
110			#
111			# we note when an element is opened so that if two open_element()
112			# calls are made successively we can end the currently open
113			# tag and will later write a proper close tag. otherwise,
114			# if a close_element() call is made directly after an open_element()
115			# call we will close the tag with a />
116			#
117			if self.element_open == 1:
118			self.file.write(">\n")
119
120			self.element_open = 1
121
122	jonathan	366	# Helper function to write an element open tag with attributes
123			self.file.write("%s<%s" % (TAB*self.indent_level, element))
124			self.write_attribs(attrs)
125	bh	268
126	jonathan	366	self.indent_level += 1
127
128			def close_element(self, element):
129			self.indent_level -= 1
130	jonathan	429	assert(self.indent_level >= 0)
131	jonathan	366
132	jonathan	391	# see open_element() for an explanation
133			if self.element_open == 1:
134			self.element_open = 0
135			self.file.write("/>\n")
136			else:
137			self.file.write("%s</%s>\n" % (TAB*self.indent_level, element))
138
139	jonathan	366	def write_element(self, element, attrs = {}):
140	jonathan	391	"""write an element that won't need a closing tag"""
141			self.open_element(element, attrs)
142			self.close_element(element)
143	jonathan	366
144	bh	268	def write_header(self):
145			"""Write the XML header"""
146	jonathan	366	self.file.write('<?xml version="1.0" encoding="UTF-8"?>\n')
147			self.file.write('<!DOCTYPE session SYSTEM "thuban.dtd">\n')
148	bh	268
149			def write_session(self, session, attrs = None, namespaces = ()):
150			"""Write the session and its contents
151
152			By default, write a session element with the title attribute and
153			call write_map for each map contained in the session.
154
155			The optional argument attrs is for additional attributes and, if
156			given, should be a mapping from attribute names to attribute
157			values. The values should not be XML-escaped yet.
158
159			The optional argument namespaces, if given, should be a sequence
160			of (name, URI) pairs. The namespaces are written as namespace
161			attributes into the session element. This is mainly useful for
162			derived classes that need to store additional information in a
163			thuban session file.
164			"""
165			if attrs is None:
166			attrs = {}
167			attrs["title"] = session.title
168			for name, uri in namespaces:
169			attrs["xmlns:" + name] = uri
170	jonathan	366	self.open_element("session", attrs)
171	bh	268	for map in session.Maps():
172			self.write_map(map)
173	jonathan	366	self.close_element("session")
174	bh	268
175			def write_map(self, map):
176			"""Write the map and its contents.
177
178			By default, write a map element element with the title
179			attribute, call write_projection to write the projection
180			element, call write_layer for each layer contained in the map
181			and finally call write_label_layer to write the label layer.
182			"""
183			write = self.file.write
184	jonathan	366	self.open_element('map title="%s"' % escape(map.title))
185	bh	268	self.write_projection(map.projection)
186			for layer in map.Layers():
187			self.write_layer(layer)
188			self.write_label_layer(map.LabelLayer())
189	jonathan	366	self.close_element('map')
190	bh	6
191	bh	268	def write_projection(self, projection):
192			"""Write the projection.
193			"""
194			if projection and len(projection.params) > 0:
195	jonathan	366	self.open_element("projection")
196	bh	268	for param in projection.params:
197	jonathan	366	self.write_element('parameter value="%s"' % escape(param))
198			self.close_element("projection")
199	bh	268
200			def write_layer(self, layer, attrs = None):
201			"""Write the layer.
202
203			The optional argument attrs is for additional attributes and, if
204			given, should be a mapping from attribute names to attribute
205			values. The values should not be XML-escaped yet.
206			"""
207	jonathan	414	lc = layer.GetClassification()
208	jonathan	391
209	bh	268	if attrs is None:
210			attrs = {}
211	jonathan	429
212			attrs["title"] = layer.title
213			attrs["filename"] = relative_filename(self.dir, layer.filename)
214			attrs["stroke"] = lc.GetDefaultStroke().hex()
215	jonathan	391	attrs["stroke_width"] = str(lc.GetDefaultStrokeWidth())
216	jonathan	429	attrs["fill"] = lc.GetDefaultFill().hex()
217	bh	268
218	jonathan	366	self.open_element("layer", attrs)
219			self.write_classification(layer)
220			self.close_element("layer")
221
222			def write_classification(self, layer, attrs = None):
223			if attrs is None:
224			attrs = {}
225
226	jonathan	414	lc = layer.GetClassification()
227	jonathan	366
228	jonathan	429	field = lc.GetField()
229	jonathan	366
230			#
231			# there isn't a classification of anything
232			# so don't do anything
233			#
234			if field is None: return
235
236			attrs["field"] = field
237			self.open_element("classification", attrs)
238
239	jonathan	429
240			# self.open_element("clnull")
241			# write_class_data(lc.GetDefaultData())
242			# self.close_element("clnull")
243
244			# just playing now with lambdas and dictionaries
245
246	jonathan	440	types = [[lambda p: 'clnull',
247			lambda p: 'clnull'],
248			[lambda p: 'clpoint value="%s"' %
249			str(p.GetValue()),
250			lambda p: 'clpoint'],
251			[lambda p: 'clrange min="%s" max="%s"' %
252			(str(p.GetMin()),
253			(str(p.GetMax()))),
254			lambda p: 'clrange']]
255	jonathan	429
256	jonathan	440	def write_class_group(group):
257			type = -1
258			if isinstance(group, ClassGroupDefault): type = 0
259			elif isinstance(group, ClassGroupSingleton): type = 1
260			elif isinstance(group, ClassGroupRange): type = 2
261			elif isinstance(group, ClassGroupMap): type = 3
262			assert(type >= 0)
263	jonathan	366
264	jonathan	440	if type <= 2:
265			data = group.GetProperties()
266			dict = {'stroke' : data.GetStroke().hex(),
267			'stroke_width': str(data.GetStrokeWidth()),
268			'fill' : data.GetFill().hex()}
269
270			self.open_element(types[type][0](group))
271			self.write_element("cldata", dict)
272			self.close_element(types[type][1](group))
273			else: pass # XXX: we need to handle maps
274
275	jonathan	429	for i in lc:
276	jonathan	440	write_class_group(i)
277	jonathan	429
278			# for i in lc:
279			# t = i.GetType()
280			# self.open_element(types[t][0](i))
281			# write_class_data(i)
282			# self.close_element(types[t][1](i))
283
284			# for p in lc:
285			# type = p.GetType()
286			# if p == ClassData.DEFAULT:
287			# lopen = lclose = 'clnull'
288			# elif p == ClassData.POINTS:
289			# lopen = 'clpoint value="%s"' % escape(str(p.GetValue()))
290			# lclose = 'clpoint'
291			# elif p == ClassData.RANGES:
292			# lopen = 'clrange min="%s" max="%s"'
293			# % (escape(str(p.GetMin())), escape(str(p.GetMax()))))
294			# lclose = 'clrange'
295
296			# self.open_element(lopen)
297			# write_class_data(p)
298			# self.close_element(lclose)
299	jonathan	391
300	jonathan	429	# if lc.points != {}:
301			# for p in lc.points.values():
302			# self.open_element('clpoint value="%s"' %
303			# (escape(str(p.GetValue()))))
304			# write_class_data(p)
305			# self.close_element('clpoint')
306			#
307			# if lc.ranges != []:
308			# for p in lc.ranges:
309			# self.open_element('clrange min="%s" max="%s"'
310			# % (escape(str(p.GetMin())), escape(str(p.GetMax()))))
311			# write_class_data(p)
312			# self.close_element('clrange')
313	jonathan	366
314			self.close_element("classification")
315
316	bh	268	def write_label_layer(self, layer):
317			"""Write the label layer.
318			"""
319			labels = layer.Labels()
320	bh	6	if labels:
321	jonathan	366	self.open_element('labellayer')
322	bh	6	for label in labels:
323	jonathan	366	self.write_element(('label x="%g" y="%g" text="%s"'
324			' halign="%s" valign="%s"')
325	bh	268	% (label.x, label.y, label.text, label.halign,
326			label.valign))
327	jonathan	366	self.close_element('labellayer')
328	bh	6
329	bh	268
330
331			def save_session(session, file, saver_class = None):
332			"""Save the session session to a file.
333
334			The file argument may either be a filename or an open file object.
335
336			The optional argument saver_class is the class to use to serialize
337			the session. By default or if it's None, the saver class will be
338			Saver.
339
340			If writing the session is successful call the session's
341			UnsetModified method
342			"""
343			if saver_class is None:
344			saver_class = Saver
345			saver = saver_class(session)
346			saver.write(file)
347
348	bh	6	# after a successful save consider the session unmodified.
349			session.UnsetModified()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision