/[thuban]/branches/WIP-pyshapelib-bramz/Thuban/Model/load.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/Thuban/Model/load.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 439 by jonathan, Thu Feb 27 15:54:05 2003 UTC revision 694 by jonathan, Wed Apr 16 16:39:18 2003 UTC
# Line 17  import sys, string, os Line 17  import sys, string, os
17    
18  import xml.sax  import xml.sax
19  import xml.sax.handler  import xml.sax.handler
20  from xml.sax import make_parser, ErrorHandler  from xml.sax import make_parser, ErrorHandler, SAXNotRecognizedException
21    
22  from Thuban import _  from Thuban import _
23  from Thuban.common import *  from Thuban.common import *
24    
25    from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
26         FIELDTYPE_STRING
27    
28  from Thuban.Model.session import Session  from Thuban.Model.session import Session
29  from Thuban.Model.map import Map  from Thuban.Model.map import Map
30  from Thuban.Model.layer import Layer  from Thuban.Model.layer import Layer
# Line 40  def parse_color(color): Line 43  def parse_color(color):
43      """      """
44      color = string.strip(color)      color = string.strip(color)
45      if color == "None":      if color == "None":
46          result = Color.None          result = Color.Transparent
47      elif color[0] == '#':      elif color[0] == '#':
48          if len(color) == 7:          if len(color) == 7:
49              r = string.atoi(color[1:3], 16) / 255.0              r = string.atoi(color[1:3], 16) / 255.0
# Line 55  def parse_color(color): Line 58  def parse_color(color):
58      return result      return result
59    
60    
61  class ProcessSession(xml.sax.handler.ContentHandler):  class XMLProcessor(xml.sax.handler.ContentHandler):
62    
63      # Dictionary mapping element names (or (URI, element name) pairs for      # Dictionary mapping element names (or (URI, element name) pairs for
64      # documents using namespaces) to method names. The methods should      # documents using namespaces) to method names. The methods should
# Line 80  class ProcessSession(xml.sax.handler.Con Line 83  class ProcessSession(xml.sax.handler.Con
83          """          """
84          self.directory = directory          self.directory = directory
85          self.chars = ''          self.chars = ''
         self.theSession = None  
         self.aMap = None  
         self.aLayer = None  
86    
87      def startElementNS(self, name, qname, attrs):      def startElementNS(self, name, qname, attrs):
88          """Call the method given for name in self.start_dispatcher          """Call the method given for name in self.start_dispatcher
# Line 106  class ProcessSession(xml.sax.handler.Con Line 106  class ProcessSession(xml.sax.handler.Con
106          if method_name is not None:          if method_name is not None:
107              getattr(self, method_name)(name, qname)              getattr(self, method_name)(name, qname)
108    
109        def GetDirectory(self):
110            return self.directory
111    
112    class ProcessSession(XMLProcessor):
113    
114        def __init__(self, directory):
115            """Inititialize the Sax handler."""
116            XMLProcessor.__init__(self, directory)
117    
118            self.theSession = None
119            self.aMap = None
120            self.aLayer = None
121    
122      def start_session(self, name, qname, attrs):      def start_session(self, name, qname, attrs):
123          self.theSession = Session(attrs.get((None, 'title'), None))          self.theSession = Session(attrs.get((None, 'title'), None))
124      start_dispatcher['session'] = "start_session"      XMLProcessor.start_dispatcher['session'] = "start_session"
125    
126      def end_session(self, name, qname):      def end_session(self, name, qname):
127          pass          pass
128      end_dispatcher['session'] = "end_session"      XMLProcessor.end_dispatcher['session'] = "end_session"
129    
130      def start_map(self, name, qname, attrs):      def start_map(self, name, qname, attrs):
131          """Start a map."""          """Start a map."""
132          self.aMap = Map(attrs.get((None, 'title'), None))          self.aMap = Map(attrs.get((None, 'title'), None))
133      start_dispatcher['map'] = "start_map"      XMLProcessor.start_dispatcher['map'] = "start_map"
134    
135      def end_map(self, name, qname):      def end_map(self, name, qname):
136          self.theSession.AddMap(self.aMap)          self.theSession.AddMap(self.aMap)
137      end_dispatcher['map'] = "end_map"      XMLProcessor.end_dispatcher['map'] = "end_map"
138    
139      def start_projection(self, name, qname, attrs):      def start_projection(self, name, qname, attrs):
140          self.ProjectionParams = [ ]          self.ProjectionParams = [ ]
141      start_dispatcher['projection'] = "start_projection"      XMLProcessor.start_dispatcher['projection'] = "start_projection"
142    
143      def end_projection(self, name, qname):      def end_projection(self, name, qname):
144          self.aMap.SetProjection(Projection(self.ProjectionParams))          self.aMap.SetProjection(Projection(self.ProjectionParams))
145      end_dispatcher['projection'] = "end_projection"      XMLProcessor.end_dispatcher['projection'] = "end_projection"
146    
147      def start_parameter(self, name, qname, attrs):      def start_parameter(self, name, qname, attrs):
148          s = attrs.get((None, 'value'))          s = attrs.get((None, 'value'))
149          s = str(s) # we can't handle unicode in proj          s = str(s) # we can't handle unicode in proj
150          self.ProjectionParams.append(s)          self.ProjectionParams.append(s)
151      start_dispatcher['parameter'] = "start_parameter"      XMLProcessor.start_dispatcher['parameter'] = "start_parameter"
152    
153      def start_layer(self, name, qname, attrs, layer_class = Layer):      def start_layer(self, name, qname, attrs, layer_class = Layer):
154          """Start a layer          """Start a layer
# Line 146  class ProcessSession(xml.sax.handler.Con Line 159  class ProcessSession(xml.sax.handler.Con
159          """          """
160          title = attrs.get((None, 'title'), "")          title = attrs.get((None, 'title'), "")
161          filename = attrs.get((None, 'filename'), "")          filename = attrs.get((None, 'filename'), "")
162          filename = os.path.join(self.directory, filename)          filename = os.path.join(self.GetDirectory(), filename)
163          fill = parse_color(attrs.get((None, 'fill'), "None"))          fill = parse_color(attrs.get((None, 'fill'), "None"))
164          stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))          stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
165          stroke_width = int(attrs.get((None, 'stroke_width'), "1"))          stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
166          self.aLayer = layer_class(title, filename, fill = fill,          self.aLayer = layer_class(title, filename, fill = fill,
167                                    stroke = stroke, stroke_width = stroke_width)                                    stroke = stroke, lineWidth = stroke_width)
168      start_dispatcher['layer'] = "start_layer"      XMLProcessor.start_dispatcher['layer'] = "start_layer"
169    
170      def end_layer(self, name, qname):      def end_layer(self, name, qname):
171          self.aMap.AddLayer(self.aLayer)          self.aMap.AddLayer(self.aLayer)
172      end_dispatcher['layer'] = "end_layer"      XMLProcessor.end_dispatcher['layer'] = "end_layer"
173    
174      def start_classification(self, name, qname, attrs):      def start_classification(self, name, qname, attrs):
175          self.aLayer.GetClassification().SetField(          field = attrs.get((None, 'field'), None)
176              attrs.get((None, 'field'), None))  
177      start_dispatcher['classification'] = "start_classification"          fieldType = attrs.get((None, 'field_type'), None)
178            dbFieldType = self.aLayer.GetFieldType(field)
179    
180            if fieldType != dbFieldType:
181                raise ValueError(_("xml field type differs from database!"))
182    
183            # setup conversion routines depending on the kind of data
184            # we will be seeing later on
185            if fieldType == FIELDTYPE_STRING:
186                self.conv = str
187            elif fieldType == FIELDTYPE_INT:
188                self.conv = lambda p: int(float(p))
189            elif fieldType == FIELDTYPE_DOUBLE:
190                self.conv = float
191    
192            self.aLayer.GetClassification().SetField(field)
193    
194        XMLProcessor.start_dispatcher['classification'] = "start_classification"
195    
196      def end_classification(self, name, qname):      def end_classification(self, name, qname):
197          pass          pass
198      end_dispatcher['classification'] = "end_classification"      XMLProcessor.end_dispatcher['classification'] = "end_classification"
199    
200      def start_clnull(self, name, qname, attrs):      def start_clnull(self, name, qname, attrs):
201          self.cl_group = ClassGroupDefault()          self.cl_group = ClassGroupDefault()
202          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
203          self.cl_prop = ClassGroupProperties()          self.cl_prop = ClassGroupProperties()
204      start_dispatcher['clnull'] = "start_clnull"      XMLProcessor.start_dispatcher['clnull'] = "start_clnull"
205    
206      def end_clnull(self, name, qname):      def end_clnull(self, name, qname):
207          self.cl_group.SetProperties(self.cl_prop)          self.cl_group.SetProperties(self.cl_prop)
208          self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)          self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
209          del self.cl_group, self.cl_prop          del self.cl_group, self.cl_prop
210      end_dispatcher['clnull'] = "end_clnull"      XMLProcessor.end_dispatcher['clnull'] = "end_clnull"
211    
212      def start_clpoint(self, name, qname, attrs):      def start_clpoint(self, name, qname, attrs):
213          attrib_value = attrs.get((None, 'value'), "0")          attrib_value = attrs.get((None, 'value'), "0")
214    
215          try:          #try:
216              value  = Str2Num(attrib_value)              #value  = Str2Num(attrib_value)
217          except:          #except:
218              value  = attrib_value              #value  = attrib_value
219    
220            value = self.conv(attrib_value)
221    
222          self.cl_group = ClassGroupSingleton(value)          self.cl_group = ClassGroupSingleton(value)
223          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
224          self.cl_prop = ClassGroupProperties()          self.cl_prop = ClassGroupProperties()
225    
226      start_dispatcher['clpoint'] = "start_clpoint"      XMLProcessor.start_dispatcher['clpoint'] = "start_clpoint"
227    
228      def end_clpoint(self, name, qname):      def end_clpoint(self, name, qname):
229          self.cl_group.SetProperties(self.cl_prop)          self.cl_group.SetProperties(self.cl_prop)
230          self.aLayer.GetClassification().AddGroup(self.cl_group)          self.aLayer.GetClassification().AppendGroup(self.cl_group)
231          del self.cl_group, self.cl_prop          del self.cl_group, self.cl_prop
232      end_dispatcher['clpoint'] = "end_clpoint"      XMLProcessor.end_dispatcher['clpoint'] = "end_clpoint"
233    
234      def start_clrange(self, name, qname, attrs):      def start_clrange(self, name, qname, attrs):
235    
236          try:          try:
237              min = Str2Num(attrs.get((None, 'min'), "0"))              min = self.conv(attrs.get((None, 'min'), "0"))
238              max = Str2Num(attrs.get((None, 'max'), "0"))              max = self.conv(attrs.get((None, 'max'), "0"))
239                #min = Str2Num(attrs.get((None, 'min'), "0"))
240                #max = Str2Num(attrs.get((None, 'max'), "0"))
241          except ValueError:          except ValueError:
242              raise ValueError(_("Classification range is not a number!"))              raise ValueError(_("Classification range is not a number!"))
243    
# Line 211  class ProcessSession(xml.sax.handler.Con Line 245  class ProcessSession(xml.sax.handler.Con
245          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
246          self.cl_prop = ClassGroupProperties()          self.cl_prop = ClassGroupProperties()
247    
248      start_dispatcher['clrange'] = "start_clrange"      XMLProcessor.start_dispatcher['clrange'] = "start_clrange"
249    
250      def end_clrange(self, name, qname):      def end_clrange(self, name, qname):
251          self.cl_group.SetProperties(self.cl_prop)          self.cl_group.SetProperties(self.cl_prop)
252          self.aLayer.GetClassification().AddGroup(self.cl_group)          self.aLayer.GetClassification().AppendGroup(self.cl_group)
253          del self.cl_group, self.cl_prop          del self.cl_group, self.cl_prop
254      end_dispatcher['clrange'] = "end_clrange"      XMLProcessor.end_dispatcher['clrange'] = "end_clrange"
255    
256      def start_cldata(self, name, qname, attrs):      def start_cldata(self, name, qname, attrs):
257          self.cl_prop.SetStroke(parse_color(attrs.get((None, 'stroke'), "None")))          self.cl_prop.SetLineColor(
258          self.cl_prop.SetStrokeWidth(              parse_color(attrs.get((None, 'stroke'), "None")))
259            self.cl_prop.SetLineWidth(
260              int(attrs.get((None, 'stroke_width'), "0")))              int(attrs.get((None, 'stroke_width'), "0")))
261          self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))          self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
262      start_dispatcher['cldata'] = "start_cldata"      XMLProcessor.start_dispatcher['cldata'] = "start_cldata"
263    
264      def end_cldata(self, name, qname):      def end_cldata(self, name, qname):
265          pass          pass
266      end_dispatcher['cldata'] = "end_cldata"      XMLProcessor.end_dispatcher['cldata'] = "end_cldata"
267    
268      def start_table(self, name, qname, attrs):      def start_table(self, name, qname, attrs):
269          print "table title: %s" % attrs.get('title', None)          #print "table title: %s" % attrs.get('title', None)
270      start_dispatcher['table'] = "start_table"          pass
271        XMLProcessor.start_dispatcher['table'] = "start_table"
272    
273      def end_table(self, name, qname):      def end_table(self, name, qname):
274          pass          pass
275      end_dispatcher['table'] = "end_table"      XMLProcessor.end_dispatcher['table'] = "end_table"
276    
277      def start_labellayer(self, name, qname, attrs):      def start_labellayer(self, name, qname, attrs):
278          self.aLayer = self.aMap.LabelLayer()          self.aLayer = self.aMap.LabelLayer()
279      start_dispatcher['labellayer'] = "start_labellayer"      XMLProcessor.start_dispatcher['labellayer'] = "start_labellayer"
280    
281      def start_label(self, name, qname, attrs):      def start_label(self, name, qname, attrs):
282          x = float(attrs[(None, 'x')])          x = float(attrs[(None, 'x')])
# Line 249  class ProcessSession(xml.sax.handler.Con Line 285  class ProcessSession(xml.sax.handler.Con
285          halign = attrs[(None, 'halign')]          halign = attrs[(None, 'halign')]
286          valign = attrs[(None, 'valign')]          valign = attrs[(None, 'valign')]
287          self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)          self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)
288      start_dispatcher['label'] = "start_label"      XMLProcessor.start_dispatcher['label'] = "start_label"
289    
290      def characters(self, chars):      def characters(self, chars):
291          pass          pass
292    
293    
294  def load_session(filename):  def load_xmlfile(filename, handler):
     """Load a Thuban session from the file object file"""  
     dir = os.path.dirname(filename)  
295      file = open(filename)      file = open(filename)
     handler = ProcessSession(dir)  
296    
297      parser = make_parser()      parser = make_parser()
298      parser.setContentHandler(handler)      parser.setContentHandler(handler)
299      parser.setErrorHandler(ErrorHandler())      parser.setErrorHandler(ErrorHandler())
300      parser.setFeature(xml.sax.handler.feature_namespaces, 1)      parser.setFeature(xml.sax.handler.feature_namespaces, 1)
301    
302        #
303        # Well, this isn't pretty, but it appears that if you
304        # use Python 2.2 without the site-package _xmlplus then
305        # the following will fail, and without them it will work.
306        # However, if you do have the site-package and you don't
307        # call these functions, the reader raises an exception
308        #
309        # The reason we set these to 0 in the first place is
310        # because there is an unresolved issue with external
311        # entities causing an exception in the reader
312        #
313        try:
314            parser.setFeature(xml.sax.handler.feature_validation, 0)
315            parser.setFeature(xml.sax.handler.feature_external_ges, 0)
316            parser.setFeature(xml.sax.handler.feature_external_pes, 0)
317        except SAXNotRecognizedException:
318            pass
319    
320      parser.parse(file)      parser.parse(file)
321    
322    def load_session(filename):
323        """Load a Thuban session from the file object file"""
324    
325        dir = os.path.dirname(filename)
326        handler = ProcessSession(dir)
327    
328        load_xmlfile(filename, handler)
329    
330      session = handler.theSession      session = handler.theSession
331      # Newly loaded session aren't modified      # Newly loaded session aren't modified
332      session.UnsetModified()      session.UnsetModified()
Legend:
Removed from v.439  
changed lines
  Added in v.694
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26