Thuban/Model/save.py

# Copyright (c) 2001, 2002 by Intevation GmbH
# Authors:
# Jan-Oliver Wagner <[email protected]>
# Bernhard Herzog <[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 string

import Thuban.Lib.fileutil

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.
        """
        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)

    def write_element(self, element, attrs, empty = 0, indentation = ""):
        # Helper function to write an element open tag with attributes
        self.file.write("%s<%s" % (indentation, element))
        for name, value in attrs.items():
            self.file.write(' %s="%s"' % (escape(name), escape(value)))
        if empty:
            self.file.write("/>\n")
        else:
            self.file.write(">\n")

    def write_header(self):
        """Write the XML header"""
        write = self.file.write
        write('<?xml version="1.0" encoding="UTF-8"?>\n')
        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.write_element("session", attrs)
        for map in session.Maps():
            self.write_map(map)
        self.file.write('</session>\n')

    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
        write('\t<map title="%s">\n' % escape(map.title))
        self.write_projection(map.projection)
        for layer in map.Layers():
            self.write_layer(layer)
        self.write_label_layer(map.LabelLayer())
        write('\t</map>\n')

    def write_projection(self, projection):
        """Write the projection.
        """
        if projection and len(projection.params) > 0:
            self.file.write('\t\t<projection>\n')
            for param in projection.params:
                self.file.write('\t\t\t<parameter value="%s"/>\n'
                                % escape(param))
            self.file.write('\t\t</projection>\n')

    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["filename"] = relative_filename(self.dir, layer.filename)
        attrs["stroke_width"] = str(layer.stroke_width)
        fill = layer.fill
        if fill is None:
            attrs["fill"] = "None"
        else:
            attrs["fill"] = fill.hex()
        stroke = layer.stroke
        if stroke is None:
            attrs["stroke"] = "None"
        else:
            attrs["stroke"] = stroke.hex()
        self.write_element("layer", attrs, empty = 1, indentation = "\t\t")

    def write_label_layer(self, layer):
        """Write the label layer.
        """
        labels = layer.Labels()
        if labels:
            self.file.write('\t\t<labellayer>\n')
            for label in labels:
                self.file.write(('\t\t\t<label x="%g" y="%g" text="%s"'
                                 ' halign="%s" valign="%s"/>\n')
                                % (label.x, label.y, label.text, label.halign,
                                   label.valign))
            self.file.write('\t\t</labellayer>\n')


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			#
6			# This program is free software under the GPL (>=v2)
7			# Read the file COPYING coming with Thuban for details.
8
9			"""
10			Functions to save a session to a file
11			"""
12
13			__version__ = "$Revision$"
14
15			import os
16			import string
17
18	bh	201	import Thuban.Lib.fileutil
19	bh	6
20	bh	201	def relative_filename(dir, filename):
21			"""Return a filename relative to dir for the absolute file name absname.
22
23			This is almost the same as the function in fileutil, except that dir
24			can be an empty string in which case filename will be returned
25			unchanged.
26			"""
27			if dir:
28			return Thuban.Lib.fileutil.relative_filename(dir, filename)
29			else:
30			return filename
31
32	bh	6	def escape(data):
33			"""Escape &, \", ', <, and > in a string of data.
34			"""
35			data = string.replace(data, "&", "&")
36			data = string.replace(data, "<", "<")
37			data = string.replace(data, ">", ">")
38			data = string.replace(data, '"', """)
39			data = string.replace(data, "'", "'")
40			return data
41
42	bh	268	class Saver:
43
44			"""Class to serialize a session into an XML file.
45
46			Applications built on top of Thuban may derive from this class and
47			override or extend the methods to save additinal information. This
48			additional information should take the form of additional attributes
49			or elements whose names are prefixed with a namespace. To define a
50			namespace derived classes should extend the write_session method to
51			pass the namespaces to the default implementation.
52			"""
53
54			def __init__(self, session):
55			self.session = session
56
57			def write(self, file_or_filename):
58			"""Write the session to a file.
59
60			The argument may be either a file object or a filename. If it's
61			a filename, the file will be opened for writing. Files of
62			shapefiles will be stored as filenames relative to the directory
63			the file is stored in (as given by os.path.dirname(filename)) if
64			they have a common parent directory other than the root
65			directory.
66
67			If the argument is a file object (which is determined by the
68			presence of a write method) all filenames will be absolut
69			filenames.
70			"""
71			if hasattr(file_or_filename, "write"):
72			# it's a file object
73			self.file = file_or_filename
74			self.dir = ""
75			else:
76			filename = file_or_filename
77			self.dir = os.path.dirname(filename)
78			self.file = open(filename, 'w')
79			self.write_header()
80			self.write_session(self.session)
81
82			def write_element(self, element, attrs, empty = 0, indentation = ""):
83			# Helper function to write an element open tag with attributes
84			self.file.write("%s<%s" % (indentation, element))
85			for name, value in attrs.items():
86			self.file.write(' %s="%s"' % (escape(name), escape(value)))
87			if empty:
88			self.file.write("/>\n")
89			else:
90			self.file.write(">\n")
91
92			def write_header(self):
93			"""Write the XML header"""
94			write = self.file.write
95			write('<?xml version="1.0" encoding="UTF-8"?>\n')
96			write('<!DOCTYPE session SYSTEM "thuban.dtd">\n')
97
98			def write_session(self, session, attrs = None, namespaces = ()):
99			"""Write the session and its contents
100
101			By default, write a session element with the title attribute and
102			call write_map for each map contained in the session.
103
104			The optional argument attrs is for additional attributes and, if
105			given, should be a mapping from attribute names to attribute
106			values. The values should not be XML-escaped yet.
107
108			The optional argument namespaces, if given, should be a sequence
109			of (name, URI) pairs. The namespaces are written as namespace
110			attributes into the session element. This is mainly useful for
111			derived classes that need to store additional information in a
112			thuban session file.
113			"""
114			if attrs is None:
115			attrs = {}
116			attrs["title"] = session.title
117			for name, uri in namespaces:
118			attrs["xmlns:" + name] = uri
119			self.write_element("session", attrs)
120			for map in session.Maps():
121			self.write_map(map)
122			self.file.write('</session>\n')
123
124			def write_map(self, map):
125			"""Write the map and its contents.
126
127			By default, write a map element element with the title
128			attribute, call write_projection to write the projection
129			element, call write_layer for each layer contained in the map
130			and finally call write_label_layer to write the label layer.
131			"""
132			write = self.file.write
133	bh	6	write('\t<map title="%s">\n' % escape(map.title))
134	bh	268	self.write_projection(map.projection)
135			for layer in map.Layers():
136			self.write_layer(layer)
137			self.write_label_layer(map.LabelLayer())
138			write('\t</map>\n')
139	bh	6
140	bh	268	def write_projection(self, projection):
141			"""Write the projection.
142			"""
143			if projection and len(projection.params) > 0:
144			self.file.write('\t\t<projection>\n')
145			for param in projection.params:
146			self.file.write('\t\t\t<parameter value="%s"/>\n'
147			% escape(param))
148			self.file.write('\t\t</projection>\n')
149
150			def write_layer(self, layer, attrs = None):
151			"""Write the layer.
152
153			The optional argument attrs is for additional attributes and, if
154			given, should be a mapping from attribute names to attribute
155			values. The values should not be XML-escaped yet.
156			"""
157			if attrs is None:
158			attrs = {}
159			attrs["title"] = layer.title
160			attrs["filename"] = relative_filename(self.dir, layer.filename)
161			attrs["stroke_width"] = str(layer.stroke_width)
162			fill = layer.fill
163			if fill is None:
164			attrs["fill"] = "None"
165			else:
166			attrs["fill"] = fill.hex()
167			stroke = layer.stroke
168			if stroke is None:
169			attrs["stroke"] = "None"
170			else:
171			attrs["stroke"] = stroke.hex()
172			self.write_element("layer", attrs, empty = 1, indentation = "\t\t")
173
174			def write_label_layer(self, layer):
175			"""Write the label layer.
176			"""
177			labels = layer.Labels()
178	bh	6	if labels:
179	bh	268	self.file.write('\t\t<labellayer>\n')
180	bh	6	for label in labels:
181	bh	268	self.file.write(('\t\t\t<label x="%g" y="%g" text="%s"'
182			' halign="%s" valign="%s"/>\n')
183			% (label.x, label.y, label.text, label.halign,
184			label.valign))
185			self.file.write('\t\t</labellayer>\n')
186	bh	6
187	bh	268
188
189			def save_session(session, file, saver_class = None):
190			"""Save the session session to a file.
191
192			The file argument may either be a filename or an open file object.
193
194			The optional argument saver_class is the class to use to serialize
195			the session. By default or if it's None, the saver class will be
196			Saver.
197
198			If writing the session is successful call the session's
199			UnsetModified method
200			"""
201			if saver_class is None:
202			saver_class = Saver
203			saver = saver_class(session)
204			saver.write(file)
205
206	bh	6	# after a successful save consider the session unmodified.
207			session.UnsetModified()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision