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

from Thuban import _
from Thuban.common import *

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.None
    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 ProcessSession(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, directory):
        """Inititialize the Sax handler.

        The directory parameter should be the directory containing the
        session file. It's needed to interpret embedded relative
        filenames.
        """
        self.directory = directory
        self.chars = ''
        self.theSession = None
        self.aMap = None
        self.aLayer = None

    def startElementNS(self, name, qname, attrs):
        """Call the method given for name in self.start_dispatcher
        """
        if name[0] is None:
            method_name = self.start_dispatcher.get(name[1])
        else:
            # Dispatch with namespace
            method_name = self.start_dispatcher.get(name)
        if method_name is not None:
            getattr(self, method_name)(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.end_dispatcher.get(name[1])
        else:
            # Dispatch with namespace
            method_name = self.end_dispatcher.get(name)
        if method_name is not None:
            getattr(self, method_name)(name, qname)

    def start_session(self, name, qname, attrs):
        self.theSession = Session(attrs.get((None, 'title'), None))
    start_dispatcher['session'] = "start_session"

    def end_session(self, name, qname):
        pass
    end_dispatcher['session'] = "end_session"

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

    def end_map(self, name, qname):
        self.theSession.AddMap(self.aMap)
    end_dispatcher['map'] = "end_map"

    def start_projection(self, name, qname, attrs):
        self.ProjectionParams = [ ]
    start_dispatcher['projection'] = "start_projection"

    def end_projection(self, name, qname):
        self.aMap.SetProjection(Projection(self.ProjectionParams))
    end_dispatcher['projection'] = "end_projection"

    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)
    start_dispatcher['parameter'] = "start_parameter"

    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.directory, 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, stroke_width = stroke_width)
    start_dispatcher['layer'] = "start_layer"

    def end_layer(self, name, qname):
        self.aMap.AddLayer(self.aLayer)
    end_dispatcher['layer'] = "end_layer"

    def start_classification(self, name, qname, attrs):
        self.aLayer.GetClassification().SetField(
            attrs.get((None, 'field'), None))
    start_dispatcher['classification'] = "start_classification"

    def end_classification(self, name, qname): 
        pass
    end_dispatcher['classification'] = "end_classification"

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

    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
    end_dispatcher['clnull'] = "end_clnull"

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

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

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

    start_dispatcher['clpoint'] = "start_clpoint"

    def end_clpoint(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AddGroup(self.cl_group)
        del self.cl_group, self.cl_prop
    end_dispatcher['clpoint'] = "end_clpoint"

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

        try:
            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()

    start_dispatcher['clrange'] = "start_clrange"

    def end_clrange(self, name, qname):
        self.cl_group.SetProperties(self.cl_prop)
        self.aLayer.GetClassification().AddGroup(self.cl_group)
        del self.cl_group, self.cl_prop
    end_dispatcher['clrange'] = "end_clrange"

    def start_cldata(self, name, qname, attrs):
        self.cl_prop.SetStroke(parse_color(attrs.get((None, 'stroke'), "None")))
        self.cl_prop.SetStrokeWidth(
            int(attrs.get((None, 'stroke_width'), "0")))
        self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
    start_dispatcher['cldata'] = "start_cldata"

    def end_cldata(self, name, qname):
        pass
    end_dispatcher['cldata'] = "end_cldata"

    def start_table(self, name, qname, attrs):
        print "table title: %s" % attrs.get('title', None)
    start_dispatcher['table'] = "start_table"

    def end_table(self, name, qname):
        pass
    end_dispatcher['table'] = "end_table"

    def start_labellayer(self, name, qname, attrs):
        self.aLayer = self.aMap.LabelLayer()
    start_dispatcher['labellayer'] = "start_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)
    start_dispatcher['label'] = "start_label"

    def characters(self, chars):
        pass


def load_session(filename):
    """Load a Thuban session from the file object file"""
    dir = os.path.dirname(filename)
    file = open(filename)
    handler = ProcessSession(dir)

    parser = make_parser()
    parser.setContentHandler(handler)
    parser.setErrorHandler(ErrorHandler())
    parser.setFeature(xml.sax.handler.feature_namespaces, 1)
    parser.parse(file)

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

    return session

1	# Copyright (C) 2001, 2002 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 GRASS for details.
9
10	"""
11	Parser for thuban session files.
12	"""
13
14	__version__ = "$Revision$"
15
16	import sys, string, os
17
18	import xml.sax
19	import xml.sax.handler
20	from xml.sax import make_parser, ErrorHandler
21
22	from Thuban import _
23	from Thuban.common import *
24
25	from Thuban.Model.session import Session
26	from Thuban.Model.map import Map
27	from Thuban.Model.layer import Layer
28	from Thuban.Model.color import Color
29	from Thuban.Model.proj import Projection
30	from Thuban.Model.classification import Classification, \
31	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
32	ClassGroupProperties
33
34
35	def parse_color(color):
36	"""Return the color object for the string color.
37
38	Color may be either 'None' or of the form '#RRGGBB' in the usual
39	HTML color notation
40	"""
41	color = string.strip(color)
42	if color == "None":
43	result = Color.None
44	elif color[0] == '#':
45	if len(color) == 7:
46	r = string.atoi(color[1:3], 16) / 255.0
47	g = string.atoi(color[3:5], 16) / 255.0
48	b = string.atoi(color[5:7], 16) / 255.0
49	result = Color(r, g, b)
50	else:
51	raise ValueError(_("Invalid hexadecimal color specification %s")
52	% color)
53	else:
54	raise ValueError(_("Invalid color specification %s") % color)
55	return result
56
57
58	class ProcessSession(xml.sax.handler.ContentHandler):
59
60	# Dictionary mapping element names (or (URI, element name) pairs for
61	# documents using namespaces) to method names. The methods should
62	# accept the same parameters as the startElement (or startElementNS)
63	# methods. The start_dispatcher is used by the default startElement
64	# and startElementNS methods to call a method for the open tag of an
65	# element.
66	start_dispatcher = {}
67
68	# end_dispatcher works just like start_dispatcher but it's used by
69	# endElement and endElementNS. The method whose names it maps to
70	# should accept the same parameters as endElement and endElementNS.
71	end_dispatcher = {}
72
73
74	def __init__(self, directory):
75	"""Inititialize the Sax handler.
76
77	The directory parameter should be the directory containing the
78	session file. It's needed to interpret embedded relative
79	filenames.
80	"""
81	self.directory = directory
82	self.chars = ''
83	self.theSession = None
84	self.aMap = None
85	self.aLayer = None
86
87	def startElementNS(self, name, qname, attrs):
88	"""Call the method given for name in self.start_dispatcher
89	"""
90	if name[0] is None:
91	method_name = self.start_dispatcher.get(name[1])
92	else:
93	# Dispatch with namespace
94	method_name = self.start_dispatcher.get(name)
95	if method_name is not None:
96	getattr(self, method_name)(name, qname, attrs)
97
98	def endElementNS(self, name, qname):
99	"""Call the method given for name in self.end_dispatcher
100	"""
101	if name[0] is None:
102	method_name = self.end_dispatcher.get(name[1])
103	else:
104	# Dispatch with namespace
105	method_name = self.end_dispatcher.get(name)
106	if method_name is not None:
107	getattr(self, method_name)(name, qname)
108
109	def start_session(self, name, qname, attrs):
110	self.theSession = Session(attrs.get((None, 'title'), None))
111	start_dispatcher['session'] = "start_session"
112
113	def end_session(self, name, qname):
114	pass
115	end_dispatcher['session'] = "end_session"
116
117	def start_map(self, name, qname, attrs):
118	"""Start a map."""
119	self.aMap = Map(attrs.get((None, 'title'), None))
120	start_dispatcher['map'] = "start_map"
121
122	def end_map(self, name, qname):
123	self.theSession.AddMap(self.aMap)
124	end_dispatcher['map'] = "end_map"
125
126	def start_projection(self, name, qname, attrs):
127	self.ProjectionParams = [ ]
128	start_dispatcher['projection'] = "start_projection"
129
130	def end_projection(self, name, qname):
131	self.aMap.SetProjection(Projection(self.ProjectionParams))
132	end_dispatcher['projection'] = "end_projection"
133
134	def start_parameter(self, name, qname, attrs):
135	s = attrs.get((None, 'value'))
136	s = str(s) # we can't handle unicode in proj
137	self.ProjectionParams.append(s)
138	start_dispatcher['parameter'] = "start_parameter"
139
140	def start_layer(self, name, qname, attrs, layer_class = Layer):
141	"""Start a layer
142
143	Instantiate a layer of class layer_class from the attributes in
144	attrs which may be a dictionary as well as the normal SAX attrs
145	object and bind it to self.aLayer.
146	"""
147	title = attrs.get((None, 'title'), "")
148	filename = attrs.get((None, 'filename'), "")
149	filename = os.path.join(self.directory, filename)
150	fill = parse_color(attrs.get((None, 'fill'), "None"))
151	stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
152	stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
153	self.aLayer = layer_class(title, filename, fill = fill,
154	stroke = stroke, stroke_width = stroke_width)
155	start_dispatcher['layer'] = "start_layer"
156
157	def end_layer(self, name, qname):
158	self.aMap.AddLayer(self.aLayer)
159	end_dispatcher['layer'] = "end_layer"
160
161	def start_classification(self, name, qname, attrs):
162	self.aLayer.GetClassification().SetField(
163	attrs.get((None, 'field'), None))
164	start_dispatcher['classification'] = "start_classification"
165
166	def end_classification(self, name, qname):
167	pass
168	end_dispatcher['classification'] = "end_classification"
169
170	def start_clnull(self, name, qname, attrs):
171	self.cl_group = ClassGroupDefault()
172	self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
173	self.cl_prop = ClassGroupProperties()
174	start_dispatcher['clnull'] = "start_clnull"
175
176	def end_clnull(self, name, qname):
177	self.cl_group.SetProperties(self.cl_prop)
178	self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
179	del self.cl_group, self.cl_prop
180	end_dispatcher['clnull'] = "end_clnull"
181
182	def start_clpoint(self, name, qname, attrs):
183	attrib_value = attrs.get((None, 'value'), "0")
184
185	try:
186	value = Str2Num(attrib_value)
187	except:
188	value = attrib_value
189
190	self.cl_group = ClassGroupSingleton(value)
191	self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
192	self.cl_prop = ClassGroupProperties()
193
194	start_dispatcher['clpoint'] = "start_clpoint"
195
196	def end_clpoint(self, name, qname):
197	self.cl_group.SetProperties(self.cl_prop)
198	self.aLayer.GetClassification().AddGroup(self.cl_group)
199	del self.cl_group, self.cl_prop
200	end_dispatcher['clpoint'] = "end_clpoint"
201
202	def start_clrange(self, name, qname, attrs):
203
204	try:
205	min = Str2Num(attrs.get((None, 'min'), "0"))
206	max = Str2Num(attrs.get((None, 'max'), "0"))
207	except ValueError:
208	raise ValueError(_("Classification range is not a number!"))
209
210	self.cl_group = ClassGroupRange(min, max)
211	self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
212	self.cl_prop = ClassGroupProperties()
213
214	start_dispatcher['clrange'] = "start_clrange"
215
216	def end_clrange(self, name, qname):
217	self.cl_group.SetProperties(self.cl_prop)
218	self.aLayer.GetClassification().AddGroup(self.cl_group)
219	del self.cl_group, self.cl_prop
220	end_dispatcher['clrange'] = "end_clrange"
221
222	def start_cldata(self, name, qname, attrs):
223	self.cl_prop.SetStroke(parse_color(attrs.get((None, 'stroke'), "None")))
224	self.cl_prop.SetStrokeWidth(
225	int(attrs.get((None, 'stroke_width'), "0")))
226	self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
227	start_dispatcher['cldata'] = "start_cldata"
228
229	def end_cldata(self, name, qname):
230	pass
231	end_dispatcher['cldata'] = "end_cldata"
232
233	def start_table(self, name, qname, attrs):
234	print "table title: %s" % attrs.get('title', None)
235	start_dispatcher['table'] = "start_table"
236
237	def end_table(self, name, qname):
238	pass
239	end_dispatcher['table'] = "end_table"
240
241	def start_labellayer(self, name, qname, attrs):
242	self.aLayer = self.aMap.LabelLayer()
243	start_dispatcher['labellayer'] = "start_labellayer"
244
245	def start_label(self, name, qname, attrs):
246	x = float(attrs[(None, 'x')])
247	y = float(attrs[(None, 'y')])
248	text = attrs[(None, 'text')]
249	halign = attrs[(None, 'halign')]
250	valign = attrs[(None, 'valign')]
251	self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)
252	start_dispatcher['label'] = "start_label"
253
254	def characters(self, chars):
255	pass
256
257
258	def load_session(filename):
259	"""Load a Thuban session from the file object file"""
260	dir = os.path.dirname(filename)
261	file = open(filename)
262	handler = ProcessSession(dir)
263
264	parser = make_parser()
265	parser.setContentHandler(handler)
266	parser.setErrorHandler(ErrorHandler())
267	parser.setFeature(xml.sax.handler.feature_namespaces, 1)
268	parser.parse(file)
269
270	session = handler.theSession
271	# Newly loaded session aren't modified
272	session.UnsetModified()
273
274	return session
275
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision