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	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			from xml.sax import make_parser, ErrorHandler
21
22	jan	374	from Thuban import _
23	jonathan	413	from Thuban.common import *
24
25	bh	6	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	jonathan	413	from Thuban.Model.classification import Classification, \
31	jonathan	439	ClassGroupDefault, ClassGroupSingleton, ClassGroupRange, ClassGroupMap, \
32			ClassGroupProperties
33	bh	6
34
35	bh	267	def parse_color(color):
36			"""Return the color object for the string color.
37	bh	6
38	bh	267	Color may be either 'None' or of the form '#RRGGBB' in the usual
39			HTML color notation
40	bh	6	"""
41			color = string.strip(color)
42			if color == "None":
43	jonathan	413	result = Color.None
44	bh	6	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	jan	374	raise ValueError(_("Invalid hexadecimal color specification %s")
52	bh	6	% color)
53			else:
54	jan	374	raise ValueError(_("Invalid color specification %s") % color)
55	bh	6	return result
56
57
58	bh	267	class ProcessSession(xml.sax.handler.ContentHandler):
59	bh	6
60	bh	267	# Dictionary mapping element names (or (URI, element name) pairs for
61	jonathan	365	# documents using namespaces) to method names. The methods should
62	bh	267	# 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	bh	6	def __init__(self, directory):
75			"""Inititialize the Sax handler.
76
77	bh	267	The directory parameter should be the directory containing the
78			session file. It's needed to interpret embedded relative
79			filenames.
80	bh	6	"""
81			self.directory = directory
82			self.chars = ''
83			self.theSession = None
84			self.aMap = None
85			self.aLayer = None
86
87	bh	267	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	bh	6
98	bh	267	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	bh	6
109	bh	267	def start_session(self, name, qname, attrs):
110			self.theSession = Session(attrs.get((None, 'title'), None))
111			start_dispatcher['session'] = "start_session"
112	bh	6
113	bh	267	def end_session(self, name, qname):
114			pass
115			end_dispatcher['session'] = "end_session"
116	bh	6
117	bh	267	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	jonathan	365	def start_classification(self, name, qname, attrs):
162	jonathan	413	self.aLayer.GetClassification().SetField(
163			attrs.get((None, 'field'), None))
164	jonathan	365	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	jonathan	439	self.cl_group = ClassGroupDefault()
172			self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
173			self.cl_prop = ClassGroupProperties()
174	jonathan	365	start_dispatcher['clnull'] = "start_clnull"
175
176			def end_clnull(self, name, qname):
177	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
178			self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
179			del self.cl_group, self.cl_prop
180	jonathan	365	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	jonathan	413	value = Str2Num(attrib_value)
187	jonathan	365	except:
188	jonathan	413	value = attrib_value
189	jonathan	365
190	jonathan	439	self.cl_group = ClassGroupSingleton(value)
191			self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
192			self.cl_prop = ClassGroupProperties()
193	jonathan	413
194	jonathan	365	start_dispatcher['clpoint'] = "start_clpoint"
195
196			def end_clpoint(self, name, qname):
197	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
198			self.aLayer.GetClassification().AddGroup(self.cl_group)
199			del self.cl_group, self.cl_prop
200	jonathan	365	end_dispatcher['clpoint'] = "end_clpoint"
201
202			def start_clrange(self, name, qname, attrs):
203
204			try:
205	jonathan	413	min = Str2Num(attrs.get((None, 'min'), "0"))
206			max = Str2Num(attrs.get((None, 'max'), "0"))
207	jonathan	365	except ValueError:
208	jan	374	raise ValueError(_("Classification range is not a number!"))
209	jonathan	365
210	jonathan	439	self.cl_group = ClassGroupRange(min, max)
211			self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
212			self.cl_prop = ClassGroupProperties()
213	jonathan	413
214	jonathan	365	start_dispatcher['clrange'] = "start_clrange"
215
216			def end_clrange(self, name, qname):
217	jonathan	439	self.cl_group.SetProperties(self.cl_prop)
218			self.aLayer.GetClassification().AddGroup(self.cl_group)
219			del self.cl_group, self.cl_prop
220	jonathan	365	end_dispatcher['clrange'] = "end_clrange"
221
222			def start_cldata(self, name, qname, attrs):
223	jonathan	439	self.cl_prop.SetStroke(parse_color(attrs.get((None, 'stroke'), "None")))
224			self.cl_prop.SetStrokeWidth(
225	jonathan	390	int(attrs.get((None, 'stroke_width'), "0")))
226	jonathan	439	self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
227	jonathan	365	start_dispatcher['cldata'] = "start_cldata"
228
229			def end_cldata(self, name, qname):
230			pass
231			end_dispatcher['cldata'] = "end_cldata"
232
233	bh	267	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	bh	6	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	bh	267	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	bh	6	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