Thuban/Model/load.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 GRASS for details.

"""
Parser for thuban session files.
"""

__version__ = "$Revision$"

import sys, string, os

import xml.sax
import xml.sax.handler
from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException

from Thuban import _
from Thuban.common import *

from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
     FIELDTYPE_STRING

from Thuban.Model.session import Session
from Thuban.Model.map import Map
from Thuban.Model.layer import Layer
from Thuban.Model.color import Color
from Thuban.Model.proj import Projection
from Thuban.Model.classification import Classification, \
    ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
    ClassGroupProperties


def parse_color(color):
    """Return the color object for the string color.

    Color may be either 'None' or of the form '#RRGGBB' in the usual
    HTML color notation
    """
    color = string.strip(color)
    if color == "None":
        result = Color.Transparent
    elif color[0] == '#':
        if len(color) == 7:
            r = string.atoi(color[1:3], 16) / 255.0
            g = string.atoi(color[3:5], 16) / 255.0
            b = string.atoi(color[5:7], 16) / 255.0
            result = Color(r, g, b)
        else:
            raise ValueError(_("Invalid hexadecimal color specification %s")
                             % color)
    else:
        raise ValueError(_("Invalid color specification %s") % color)
    return result


class XMLReader(xml.sax.handler.ContentHandler):

    # Dictionary mapping element names (or (URI, element name) pairs for
    # documents using namespaces) to method names. The methods should
    # accept the same parameters as the startElement (or startElementNS)
    # methods. The start_dispatcher is used by the default startElement
    # and startElementNS methods to call a method for the open tag of an
    # element.
    start_dispatcher = {}

    # end_dispatcher works just like start_dispatcher but it's used by
    # endElement and endElementNS. The method whose names it maps to
    # should accept the same parameters as endElement and endElementNS.
    end_dispatcher = {}


    def __init__(self):
        self.chars = ''
        self.__parser = None
        self.__directory = ""
        self.__dispatchers = {}

    def read(self, file_or_filename):

        if hasattr(file_or_filename, "read"):
            # it's a file object
            self.__directory = ""
            self.__file = file_or_filename
        else:
            filename = file_or_filename
            self.__directory = os.path.dirname(filename)
            self.__file = open(filename)

        if self.__parser is None:
            self.__parser = make_parser()
            self.__parser.setContentHandler(self)
            self.__parser.setErrorHandler(ErrorHandler())
            self.__parser.setFeature(xml.sax.handler.feature_namespaces, 1)

            #
            # Well, this isn't pretty, but it appears that if you
            # use Python 2.2 without the site-package _xmlplus then
            # the following will fail, and without them it will work.
            # However, if you do have the site-package and you don't
            # call these functions, the reader raises an exception
            #
            # The reason we set these to 0 in the first place is 
            # because there is an unresolved issue with external
            # entities causing an exception in the reader
            #
            try:
                self.__parser.setFeature(xml.sax.handler.feature_validation,0)
                self.__parser.setFeature(xml.sax.handler.feature_external_ges,0)
                self.__parser.setFeature(xml.sax.handler.feature_external_pes,0)
            except SAXNotRecognizedException:
                pass

        self.__parser.parse(self.__file)

        self.close()

    def close(self):
        self.__file.close()
        
    def GetFileName(self):
        if hasattr(self.__file, "name"):
            return self.__file.name

        return ""

    def GetDirectory(self):
        return self.__directory


    def AddDispatchers(self, dict):
        """Add the function names that should be used to process XML tags.

        dict -- a dictionary whose keys are XML tag strings and whose values
                are pairs of strings such that the first string is
                the name of the function that should be called when the
                XML tag opens and the second string is the name of the
                function that should be called when the XML tag closes.
                If a pair element is None, no function is called.
        """

        self.__dispatchers.update(dict)

    def startElementNS(self, name, qname, attrs):
        """Call the method given for name in self.start_dispatcher
        """
        if name[0] is None:
            method_name = self.__dispatchers.get(name[1])
        else:
            # Dispatch with namespace
            method_name = self.__dispatchers.get(name)
        if method_name is not None and method_name[0] is not None:
            getattr(self, method_name[0])(name, qname, attrs)

    def endElementNS(self, name, qname):
        """Call the method given for name in self.end_dispatcher
        """
        if name[0] is None:
            method_name = self.__dispatchers.get(name[1])
        else:
            # Dispatch with namespace
            method_name = self.__dispatchers.get(name)
        if method_name is not None and method_name[1] is not None:
            getattr(self, method_name[1])(name, qname)

class SessionLoader(XMLReader):

    def __init__(self):
        """Inititialize the Sax handler."""
        XMLReader.__init__(self)

        self.theSession = None
        self.aMap = None
        self.aLayer = None

        XMLReader.AddDispatchers(self,
            {'session'       : ("start_session",        "end_session"),
             'map'           : ("start_map",            "end_map"),
             'projection'    : ("start_projection",     "end_projection"),
             'parameter'     : ("start_parameter",      None),
             'layer'         : ("start_layer",          "end_layer"),
             'classification': ("start_classification", "end_classification"),
             'clnull'        : ("start_clnull",         "end_clnull"),
             'clpoint'       : ("start_clpoint",        "end_clpoint"),
             'clrange'       : ("start_clrange",        "end_clrange"),
             'cldata'        : ("start_cldata",         "end_cldata"),
             'table'         : ("start_table",          "end_table"),
             'labellayer'    : ("start_labellayer",     None),
             'label'         : ("start_label",          None)})

    def start_session(self, name, qname, attrs):
        self.theSession = Session(attrs.get((None, 'title'), None))

    def end_session(self, name, qname):
        pass

    def start_map(self, name, qname, attrs):
        """Start a map."""
        self.aMap = Map(attrs.get((None, 'title'), None))

    def end_map(self, name, qname):
        self.theSession.AddMap(self.aMap)

    def start_projection(self, name, qname, attrs):
        self.ProjectionParams = [ ]

    def end_projection(self, name, qname):
        self.aMap.SetProjection(Projection(self.ProjectionParams))

    def start_parameter(self, name, qname, attrs):
        s = attrs.get((None, 'value'))
        s = str(s) # we can't handle unicode in proj
        self.ProjectionParams.append(s)

    def start_layer(self, name, qname, attrs, layer_class = Layer):
        """Start a layer

        Instantiate a layer of class layer_class from the attributes in
        attrs which may be a dictionary as well as the normal SAX attrs
        object and bind it to self.aLayer.
        """
        title = attrs.get((None, 'title'), "")
        filename = attrs.get((None, 'filename'), "")
        filename = os.path.join(self.GetDirectory(), filename)
        fill = parse_color(attrs.get((None, 'fill'), "None"))
        stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
        stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
        self.aLayer = layer_class(title, filename, fill = fill,
                                  stroke = stroke, lineWidth = stroke_width)

    def end_layer(self, name, qname):
        self.aMap.AddLayer(self.aLayer)

    def start_classification(self, name, qname, attrs):
        field = attrs.get((None, 'field'), None)

        fieldType = attrs.get((None, 'field_type'), None)
        dbFieldType = self.aLayer.GetFieldType(field)

        if fieldType != dbFieldType:
            raise ValueError(_("xml field type differs from database!"))

        # setup conversion routines depending on the kind of data
        # we will be seeing later on
        if fieldType == FIELDTYPE_STRING:
            self.conv = str
        elif fieldType == FIELDTYPE_INT:
            self.conv = lambda p: int(float(p))
        elif fieldType == FIELDTYPE_DOUBLE:
            self.conv = float

        self.aLayer.GetClassification().SetField(field)


    def end_classification(self, name, qname): 
        pass

    def start_clnull(self, name, qname, attrs):
        self.cl_group = ClassGroupDefault()
        self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
        self.cl_prop = ClassGroupProperties()

    def end_clnull(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_clpoint(self, name, qname, attrs):
        attrib_value = attrs.get((None, 'value'), "0")

        #try:
            #value  = Str2Num(attrib_value)
        #except:
            #value  = attrib_value

        value = self.conv(attrib_value)

        self.cl_group = ClassGroupSingleton(value)
        self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
        self.cl_prop = ClassGroupProperties()


    def end_clpoint(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AppendGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_clrange(self, name, qname, attrs):

        try:
            min = self.conv(attrs.get((None, 'min'), "0"))
            max = self.conv(attrs.get((None, 'max'), "0"))
            #min = Str2Num(attrs.get((None, 'min'), "0"))
            #max = Str2Num(attrs.get((None, 'max'), "0"))
        except ValueError:
            raise ValueError(_("Classification range is not a number!"))

        self.cl_group = ClassGroupRange(min, max)
        self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
        self.cl_prop = ClassGroupProperties()


    def end_clrange(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AppendGroup(self.cl_group)
        del self.cl_group, self.cl_prop

    def start_cldata(self, name, qname, attrs):
        self.cl_prop.SetLineColor(
            parse_color(attrs.get((None, 'stroke'), "None")))
        self.cl_prop.SetLineWidth(
            int(attrs.get((None, 'stroke_width'), "0")))
        self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))

    def end_cldata(self, name, qname):
        pass

    def start_table(self, name, qname, attrs):
        #print "table title: %s" % attrs.get('title', None)
        pass

    def end_table(self, name, qname):
        pass

    def start_labellayer(self, name, qname, attrs):
        self.aLayer = self.aMap.LabelLayer()

    def start_label(self, name, qname, attrs):
        x = float(attrs[(None, 'x')])
        y = float(attrs[(None, 'y')])
        text = attrs[(None, 'text')]
        halign = attrs[(None, 'halign')]
        valign = attrs[(None, 'valign')]
        self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)

    def characters(self, chars):
        pass


def load_session(filename):
    """Load a Thuban session from the file object file"""

    handler = SessionLoader()
    handler.read(filename)

    session = handler.theSession
    # Newly loaded session aren't modified
    session.UnsetModified()

    return session

1	bh	75	# Copyright (C) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Jan-Oliver Wagner <[email protected]>
4	bh	267	# Bernhard Herzog <[email protected]>
5	jonathan	413	# Jonathan Coles <[email protected]>
6	bh	6	#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with GRASS for details.
9
10			"""
11			Parser for thuban session files.
12			"""
13
14			__version__ = "$Revision$"
15
16			import sys, string, os
17	bh	267
18			import xml.sax
19			import xml.sax.handler
20	jonathan	526	from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
21	bh	267
22	jan	374	from Thuban import _
23	jonathan	413	from Thuban.common import *
24
25	jonathan	473	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
26			FIELDTYPE_STRING
27
28	bh	6	from Thuban.Model.session import Session
29			from Thuban.Model.map import Map
30			from Thuban.Model.layer import Layer
31			from Thuban.Model.color import Color
32			from Thuban.Model.proj import Projection
33	jonathan	413	from Thuban.Model.classification import Classification, \
34	jonathan	439	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
35			ClassGroupProperties
36	bh	6
37
38	bh	267	def parse_color(color):
39			"""Return the color object for the string color.
40	bh	6
41	bh	267	Color may be either 'None' or of the form '#RRGGBB' in the usual
42			HTML color notation
43	bh	6	"""
44			color = string.strip(color)
45			if color == "None":
46	jonathan	610	result = Color.Transparent
47	bh	6	elif color[0] == '#':
48			if len(color) == 7:
49			r = string.atoi(color[1:3], 16) / 255.0
50			g = string.atoi(color[3:5], 16) / 255.0
51			b = string.atoi(color[5:7], 16) / 255.0
52			result = Color(r, g, b)
53			else:
54	jan	374	raise ValueError(_("Invalid hexadecimal color specification %s")
55	bh	6	% color)
56			else:
57	jan	374	raise ValueError(_("Invalid color specification %s") % color)
58	bh	6	return result
59
60
61	jonathan	706	class XMLReader(xml.sax.handler.ContentHandler):
62	bh	6
63	bh	267	# Dictionary mapping element names (or (URI, element name) pairs for
64	jonathan	365	# documents using namespaces) to method names. The methods should
65	bh	267	# accept the same parameters as the startElement (or startElementNS)
66			# methods. The start_dispatcher is used by the default startElement
67			# and startElementNS methods to call a method for the open tag of an
68			# element.
69			start_dispatcher = {}
70
71			# end_dispatcher works just like start_dispatcher but it's used by
72			# endElement and endElementNS. The method whose names it maps to
73			# should accept the same parameters as endElement and endElementNS.
74			end_dispatcher = {}
75
76
77	jonathan	706	def __init__(self):
78	bh	6	self.chars = ''
79	jonathan	706	self.__parser = None
80			self.__directory = ""
81			self.__dispatchers = {}
82	bh	6
83	jonathan	706	def read(self, file_or_filename):
84
85	jonathan	722	if hasattr(file_or_filename, "read"):
86	jonathan	706	# it's a file object
87			self.__directory = ""
88			self.__file = file_or_filename
89			else:
90			filename = file_or_filename
91			self.__directory = os.path.dirname(filename)
92			self.__file = open(filename)
93
94			if self.__parser is None:
95			self.__parser = make_parser()
96			self.__parser.setContentHandler(self)
97			self.__parser.setErrorHandler(ErrorHandler())
98			self.__parser.setFeature(xml.sax.handler.feature_namespaces, 1)
99
100			#
101			# Well, this isn't pretty, but it appears that if you
102			# use Python 2.2 without the site-package _xmlplus then
103			# the following will fail, and without them it will work.
104			# However, if you do have the site-package and you don't
105			# call these functions, the reader raises an exception
106			#
107			# The reason we set these to 0 in the first place is
108			# because there is an unresolved issue with external
109			# entities causing an exception in the reader
110			#
111			try:
112			self.__parser.setFeature(xml.sax.handler.feature_validation,0)
113			self.__parser.setFeature(xml.sax.handler.feature_external_ges,0)
114			self.__parser.setFeature(xml.sax.handler.feature_external_pes,0)
115			except SAXNotRecognizedException:
116			pass
117
118			self.__parser.parse(self.__file)
119
120			self.close()
121
122			def close(self):
123			self.__file.close()
124
125			def GetFileName(self):
126			if hasattr(self.__file, "name"):
127			return self.__file.name
128
129			return ""
130
131			def GetDirectory(self):
132			return self.__directory
133
134
135			def AddDispatchers(self, dict):
136	jonathan	722	"""Add the function names that should be used to process XML tags.
137
138			dict -- a dictionary whose keys are XML tag strings and whose values
139			are pairs of strings such that the first string is
140			the name of the function that should be called when the
141			XML tag opens and the second string is the name of the
142			function that should be called when the XML tag closes.
143			If a pair element is None, no function is called.
144			"""
145
146	jonathan	706	self.__dispatchers.update(dict)
147
148	bh	267	def startElementNS(self, name, qname, attrs):
149			"""Call the method given for name in self.start_dispatcher
150			"""
151			if name[0] is None:
152	jonathan	706	method_name = self.__dispatchers.get(name[1])
153	bh	267	else:
154			# Dispatch with namespace
155	jonathan	706	method_name = self.__dispatchers.get(name)
156	jonathan	722	if method_name is not None and method_name[0] is not None:
157	jonathan	706	getattr(self, method_name[0])(name, qname, attrs)
158	bh	6
159	bh	267	def endElementNS(self, name, qname):
160			"""Call the method given for name in self.end_dispatcher
161			"""
162			if name[0] is None:
163	jonathan	706	method_name = self.__dispatchers.get(name[1])
164	bh	267	else:
165			# Dispatch with namespace
166	jonathan	706	method_name = self.__dispatchers.get(name)
167	jonathan	722	if method_name is not None and method_name[1] is not None:
168	jonathan	706	getattr(self, method_name[1])(name, qname)
169	bh	6
170	jonathan	706	class SessionLoader(XMLReader):
171	jonathan	694
172	jonathan	706	def __init__(self):
173	jonathan	694	"""Inititialize the Sax handler."""
174	jonathan	706	XMLReader.__init__(self)
175	jonathan	694
176			self.theSession = None
177			self.aMap = None
178			self.aLayer = None
179
180	jonathan	706	XMLReader.AddDispatchers(self,
181			{'session' : ("start_session", "end_session"),
182			'map' : ("start_map", "end_map"),
183			'projection' : ("start_projection", "end_projection"),
184			'parameter' : ("start_parameter", None),
185			'layer' : ("start_layer", "end_layer"),
186			'classification': ("start_classification", "end_classification"),
187			'clnull' : ("start_clnull", "end_clnull"),
188			'clpoint' : ("start_clpoint", "end_clpoint"),
189			'clrange' : ("start_clrange", "end_clrange"),
190			'cldata' : ("start_cldata", "end_cldata"),
191			'table' : ("start_table", "end_table"),
192			'labellayer' : ("start_labellayer", None),
193			'label' : ("start_label", None)})
194
195	bh	267	def start_session(self, name, qname, attrs):
196			self.theSession = Session(attrs.get((None, 'title'), None))
197	bh	6
198	bh	267	def end_session(self, name, qname):
199			pass
200	bh	6
201	bh	267	def start_map(self, name, qname, attrs):
202			"""Start a map."""
203			self.aMap = Map(attrs.get((None, 'title'), None))
204
205			def end_map(self, name, qname):
206			self.theSession.AddMap(self.aMap)
207
208			def start_projection(self, name, qname, attrs):
209			self.ProjectionParams = [ ]
210
211			def end_projection(self, name, qname):
212			self.aMap.SetProjection(Projection(self.ProjectionParams))
213
214			def start_parameter(self, name, qname, attrs):
215			s = attrs.get((None, 'value'))
216			s = str(s) # we can't handle unicode in proj
217			self.ProjectionParams.append(s)
218
219			def start_layer(self, name, qname, attrs, layer_class = Layer):
220			"""Start a layer
221
222			Instantiate a layer of class layer_class from the attributes in
223			attrs which may be a dictionary as well as the normal SAX attrs
224			object and bind it to self.aLayer.
225			"""
226			title = attrs.get((None, 'title'), "")
227			filename = attrs.get((None, 'filename'), "")
228	jonathan	694	filename = os.path.join(self.GetDirectory(), filename)
229	bh	267	fill = parse_color(attrs.get((None, 'fill'), "None"))
230			stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
231			stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
232			self.aLayer = layer_class(title, filename, fill = fill,
233	jonathan	465	stroke = stroke, lineWidth = stroke_width)
234	bh	267
235			def end_layer(self, name, qname):
236			self.aMap.AddLayer(self.aLayer)
237
238	jonathan	365	def start_classification(self, name, qname, attrs):
239	jonathan	465	field = attrs.get((None, 'field'), None)
240
241			fieldType = attrs.get((None, 'field_type'), None)
242			dbFieldType = self.aLayer.GetFieldType(field)
243
244			if fieldType != dbFieldType:
245			raise ValueError(_("xml field type differs from database!"))
246
247			# setup conversion routines depending on the kind of data
248			# we will be seeing later on
249			if fieldType == FIELDTYPE_STRING:
250			self.conv = str
251			elif fieldType == FIELDTYPE_INT:
252			self.conv = lambda p: int(float(p))
253			elif fieldType == FIELDTYPE_DOUBLE:
254			self.conv = float
255
256			self.aLayer.GetClassification().SetField(field)
257
258	jonathan	365
259			def end_classification(self, name, qname):
260			pass
261
262			def start_clnull(self, name, qname, attrs):
263	jonathan	439	self.cl_group = ClassGroupDefault()
264			self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
265			self.cl_prop = ClassGroupProperties()
266	jonathan	365
267			def end_clnull(self, name, qname):
268	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
269			self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
270			del self.cl_group, self.cl_prop
271	jonathan	365
272			def start_clpoint(self, name, qname, attrs):
273			attrib_value = attrs.get((None, 'value'), "0")
274
275	jonathan	465	#try:
276			#value = Str2Num(attrib_value)
277			#except:
278			#value = attrib_value
279	jonathan	365
280	jonathan	465	value = self.conv(attrib_value)
281
282	jonathan	439	self.cl_group = ClassGroupSingleton(value)
283			self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
284			self.cl_prop = ClassGroupProperties()
285	jonathan	413
286	jonathan	365
287			def end_clpoint(self, name, qname):
288	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
289	jonathan	614	self.aLayer.GetClassification().AppendGroup(self.cl_group)
290	jonathan	439	del self.cl_group, self.cl_prop
291	jonathan	365
292			def start_clrange(self, name, qname, attrs):
293
294			try:
295	jonathan	465	min = self.conv(attrs.get((None, 'min'), "0"))
296			max = self.conv(attrs.get((None, 'max'), "0"))
297			#min = Str2Num(attrs.get((None, 'min'), "0"))
298			#max = Str2Num(attrs.get((None, 'max'), "0"))
299	jonathan	365	except ValueError:
300	jan	374	raise ValueError(_("Classification range is not a number!"))
301	jonathan	365
302	jonathan	439	self.cl_group = ClassGroupRange(min, max)
303			self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
304			self.cl_prop = ClassGroupProperties()
305	jonathan	413
306	jonathan	365
307			def end_clrange(self, name, qname):
308	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
309	jonathan	614	self.aLayer.GetClassification().AppendGroup(self.cl_group)
310	jonathan	439	del self.cl_group, self.cl_prop
311	jonathan	365
312			def start_cldata(self, name, qname, attrs):
313	jonathan	465	self.cl_prop.SetLineColor(
314			parse_color(attrs.get((None, 'stroke'), "None")))
315			self.cl_prop.SetLineWidth(
316	jonathan	390	int(attrs.get((None, 'stroke_width'), "0")))
317	jonathan	439	self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
318	jonathan	365
319			def end_cldata(self, name, qname):
320			pass
321
322	bh	267	def start_table(self, name, qname, attrs):
323	jonathan	493	#print "table title: %s" % attrs.get('title', None)
324			pass
325	bh	267
326			def end_table(self, name, qname):
327			pass
328
329			def start_labellayer(self, name, qname, attrs):
330			self.aLayer = self.aMap.LabelLayer()
331
332			def start_label(self, name, qname, attrs):
333			x = float(attrs[(None, 'x')])
334			y = float(attrs[(None, 'y')])
335			text = attrs[(None, 'text')]
336			halign = attrs[(None, 'halign')]
337			valign = attrs[(None, 'valign')]
338			self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)
339
340			def characters(self, chars):
341			pass
342
343
344	jonathan	694	def load_session(filename):
345			"""Load a Thuban session from the file object file"""
346
347	jonathan	706	handler = SessionLoader()
348			handler.read(filename)
349	jonathan	694
350	bh	6	session = handler.theSession
351			# Newly loaded session aren't modified
352			session.UnsetModified()
353
354			return session
355
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision