Thuban/Model/save.py

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

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

__version__ = "$Revision$"

import os

import Thuban.Lib.fileutil

from Thuban.Model.color import Color 
from Thuban.Model.layer import Layer, RasterLayer

from Thuban.Model.classification import \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap

from Thuban.Model.xmlwriter import XMLWriter

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

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

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

        self.write_header("session", "thuban.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
        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.
        """
        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:
            self.open_element("projection", {"name": projection.GetName()})
            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["filename"] = relative_filename(self.dir,
                                                layer.ShapeStore().FileName())

            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"] = relative_filename(self.dir, layer.filename)
            self.open_element("rasterlayer", attrs)
            self.write_projection(layer.GetProjection())
            self.close_element("rasterlayer")

    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
        attrs["field_type"] = str(lc.GetFieldType())
        self.open_element("classification", attrs)


        types = [[lambda p: 'clnull label="%s"' % self.encode(p.GetLabel()),
                  lambda p: 'clnull'],
                 [lambda p: 'clpoint label="%s" value="%s"' % 
                             (self.encode(p.GetLabel()), str(p.GetValue())),
                  lambda p: 'clpoint'],
                 [lambda p: 'clrange label="%s" range="%s"' % 
                             (self.encode(p.GetLabel()),
                              str(p.GetRange())),
                  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.GetLineColor().hex(),
                        'stroke_width': str(data.GetLineWidth()),
                        '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)

        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, 2002, 2003 by Intevation GmbH
2	# Authors:
3	# Jan-Oliver Wagner <[email protected]>
4	# Bernhard Herzog <[email protected]>
5	# Jonathan Coles <[email protected]>
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	import Thuban.Lib.fileutil
19
20	from Thuban.Model.color import Color
21	from Thuban.Model.layer import Layer, RasterLayer
22
23	from Thuban.Model.classification import \
24	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap
25
26	from Thuban.Model.xmlwriter import XMLWriter
27
28	def relative_filename(dir, filename):
29	"""Return a filename relative to dir for the absolute file name absname.
30
31	This is almost the same as the function in fileutil, except that dir
32	can be an empty string in which case filename will be returned
33	unchanged.
34	"""
35	if dir:
36	return Thuban.Lib.fileutil.relative_filename(dir, filename)
37	else:
38	return filename
39
40	class SessionSaver(XMLWriter):
41
42	"""Class to serialize a session into an XML file.
43
44	Applications built on top of Thuban may derive from this class and
45	override or extend the methods to save additional information. This
46	additional information should take the form of additional attributes
47	or elements whose names are prefixed with a namespace. To define a
48	namespace derived classes should extend the write_session method to
49	pass the namespaces to the default implementation.
50	"""
51
52
53	def __init__(self, session):
54	XMLWriter.__init__(self)
55	self.session = session
56
57	def write(self, file_or_filename):
58	XMLWriter.write(self, file_or_filename)
59
60	self.write_header("session", "thuban.dtd")
61	self.write_session(self.session)
62	self.close()
63
64	def write_session(self, session, attrs = None, namespaces = ()):
65	"""Write the session and its contents
66
67	By default, write a session element with the title attribute and
68	call write_map for each map contained in the session.
69
70	The optional argument attrs is for additional attributes and, if
71	given, should be a mapping from attribute names to attribute
72	values. The values should not be XML-escaped yet.
73
74	The optional argument namespaces, if given, should be a sequence
75	of (name, URI) pairs. The namespaces are written as namespace
76	attributes into the session element. This is mainly useful for
77	derived classes that need to store additional information in a
78	thuban session file.
79	"""
80	if attrs is None:
81	attrs = {}
82	attrs["title"] = session.title
83	for name, uri in namespaces:
84	attrs["xmlns:" + name] = uri
85	self.open_element("session", attrs)
86	for map in session.Maps():
87	self.write_map(map)
88	self.close_element("session")
89
90	def write_map(self, map):
91	"""Write the map and its contents.
92
93	By default, write a map element element with the title
94	attribute, call write_projection to write the projection
95	element, call write_layer for each layer contained in the map
96	and finally call write_label_layer to write the label layer.
97	"""
98	self.open_element('map title="%s"' % self.encode(map.title))
99	self.write_projection(map.projection)
100	for layer in map.Layers():
101	self.write_layer(layer)
102	self.write_label_layer(map.LabelLayer())
103	self.close_element('map')
104
105	def write_projection(self, projection):
106	"""Write the projection.
107	"""
108	if projection and len(projection.params) > 0:
109	self.open_element("projection", {"name": projection.GetName()})
110	for param in projection.params:
111	self.write_element('parameter value="%s"' %
112	self.encode(param))
113	self.close_element("projection")
114
115	def write_layer(self, layer, attrs = None):
116	"""Write the layer.
117
118	The optional argument attrs is for additional attributes and, if
119	given, should be a mapping from attribute names to attribute
120	values. The values should not be XML-escaped yet.
121	"""
122
123	if attrs is None:
124	attrs = {}
125
126	attrs["title"] = layer.title
127	attrs["visible"] = ("false", "true")[int(layer.Visible())]
128
129	if isinstance(layer, Layer):
130	attrs["filename"] = relative_filename(self.dir,
131	layer.ShapeStore().FileName())
132
133	lc = layer.GetClassification()
134	attrs["stroke"] = lc.GetDefaultLineColor().hex()
135	attrs["stroke_width"] = str(lc.GetDefaultLineWidth())
136	attrs["fill"] = lc.GetDefaultFill().hex()
137
138	self.open_element("layer", attrs)
139	self.write_projection(layer.GetProjection())
140	self.write_classification(layer)
141	self.close_element("layer")
142
143	elif isinstance(layer, RasterLayer):
144	attrs["filename"] = relative_filename(self.dir, layer.filename)
145	self.open_element("rasterlayer", attrs)
146	self.write_projection(layer.GetProjection())
147	self.close_element("rasterlayer")
148
149	def write_classification(self, layer, attrs = None):
150	if attrs is None:
151	attrs = {}
152
153	lc = layer.GetClassification()
154
155	field = lc.GetField()
156
157	#
158	# there isn't a classification of anything
159	# so don't do anything
160	#
161	if field is None: return
162
163	attrs["field"] = field
164	attrs["field_type"] = str(lc.GetFieldType())
165	self.open_element("classification", attrs)
166
167
168	types = [[lambda p: 'clnull label="%s"' % self.encode(p.GetLabel()),
169	lambda p: 'clnull'],
170	[lambda p: 'clpoint label="%s" value="%s"' %
171	(self.encode(p.GetLabel()), str(p.GetValue())),
172	lambda p: 'clpoint'],
173	[lambda p: 'clrange label="%s" range="%s"' %
174	(self.encode(p.GetLabel()),
175	str(p.GetRange())),
176	lambda p: 'clrange']]
177
178	def write_class_group(group):
179	type = -1
180	if isinstance(group, ClassGroupDefault): type = 0
181	elif isinstance(group, ClassGroupSingleton): type = 1
182	elif isinstance(group, ClassGroupRange): type = 2
183	elif isinstance(group, ClassGroupMap): type = 3
184	assert type >= 0
185
186	if type <= 2:
187	data = group.GetProperties()
188	dict = {'stroke' : data.GetLineColor().hex(),
189	'stroke_width': str(data.GetLineWidth()),
190	'fill' : data.GetFill().hex()}
191
192	self.open_element(types[type][0](group))
193	self.write_element("cldata", dict)
194	self.close_element(types[type][1](group))
195	else: pass # XXX: we need to handle maps
196
197	for i in lc:
198	write_class_group(i)
199
200	self.close_element("classification")
201
202	def write_label_layer(self, layer):
203	"""Write the label layer.
204	"""
205	labels = layer.Labels()
206	if labels:
207	self.open_element('labellayer')
208	for label in labels:
209	self.write_element(('label x="%g" y="%g" text="%s"'
210	' halign="%s" valign="%s"')
211	% (label.x, label.y,
212	self.encode(label.text),
213	label.halign,
214	label.valign))
215	self.close_element('labellayer')
216
217
218
219	def save_session(session, file, saver_class = None):
220	"""Save the session session to a file.
221
222	The file argument may either be a filename or an open file object.
223
224	The optional argument saver_class is the class to use to serialize
225	the session. By default or if it's None, the saver class will be
226	SessionSaver.
227
228	If writing the session is successful call the session's
229	UnsetModified method
230	"""
231	if saver_class is None:
232	saver_class = SessionSaver
233	saver = saver_class(session)
234	saver.write(file)
235
236	# after a successful save consider the session unmodified.
237	session.UnsetModified()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision