/[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 493 by jonathan, Mon Mar 10 10:45:10 2003 UTC revision 706 by jonathan, Wed Apr 23 08:44:21 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 *
# Line 43  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 58  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 XMLReader(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 74  class ProcessSession(xml.sax.handler.Con Line 74  class ProcessSession(xml.sax.handler.Con
74      end_dispatcher = {}      end_dispatcher = {}
75    
76    
77      def __init__(self, directory):      def __init__(self):
         """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  
78          self.chars = ''          self.chars = ''
79          self.theSession = None          self.__parser = None
80          self.aMap = None          self.__directory = ""
81          self.aLayer = None          self.__dispatchers = {}
82    
83        def read(self, file_or_filename):
84    
85            if hasattr(file_or_filename, "write"):
86                # 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            self.__dispatchers.update(dict)
137    
138            #for key, (start, end) in dict.iteritems():
139                #if start is not None: self.start_dispatcher[key] = start
140                #if end   is not None: self.end_dispatcher[key]   = end
141    
142      def startElementNS(self, name, qname, attrs):      def startElementNS(self, name, qname, attrs):
143          """Call the method given for name in self.start_dispatcher          """Call the method given for name in self.start_dispatcher
144          """          """
145          if name[0] is None:          if name[0] is None:
146              method_name = self.start_dispatcher.get(name[1])              method_name = self.__dispatchers.get(name[1])
147                #method_name = self.start_dispatcher.get(name[1])
148          else:          else:
149              # Dispatch with namespace              # Dispatch with namespace
150              method_name = self.start_dispatcher.get(name)              method_name = self.__dispatchers.get(name)
151          if method_name is not None:          if method_name is not None \
152              getattr(self, method_name)(name, qname, attrs)              and method_name[0] is not None:
153                getattr(self, method_name[0])(name, qname, attrs)
154    
155      def endElementNS(self, name, qname):      def endElementNS(self, name, qname):
156          """Call the method given for name in self.end_dispatcher          """Call the method given for name in self.end_dispatcher
157          """          """
158          if name[0] is None:          if name[0] is None:
159              method_name = self.end_dispatcher.get(name[1])              method_name = self.__dispatchers.get(name[1])
160                #method_name = self.end_dispatcher.get(name[1])
161          else:          else:
162              # Dispatch with namespace              # Dispatch with namespace
163              method_name = self.end_dispatcher.get(name)              method_name = self.__dispatchers.get(name)
164          if method_name is not None:          if method_name is not None \
165              getattr(self, method_name)(name, qname)              and method_name[1] is not None:
166                getattr(self, method_name[1])(name, qname)
167    
168    class SessionLoader(XMLReader):
169    
170        def __init__(self):
171            """Inititialize the Sax handler."""
172            XMLReader.__init__(self)
173    
174            self.theSession = None
175            self.aMap = None
176            self.aLayer = None
177    
178            XMLReader.AddDispatchers(self,
179                {'session'       : ("start_session",        "end_session"),
180                 'map'           : ("start_map",            "end_map"),
181                 'projection'    : ("start_projection",     "end_projection"),
182                 'parameter'     : ("start_parameter",      None),
183                 'layer'         : ("start_layer",          "end_layer"),
184                 'classification': ("start_classification", "end_classification"),
185                 'clnull'        : ("start_clnull",         "end_clnull"),
186                 'clpoint'       : ("start_clpoint",        "end_clpoint"),
187                 'clrange'       : ("start_clrange",        "end_clrange"),
188                 'cldata'        : ("start_cldata",         "end_cldata"),
189                 'table'         : ("start_table",          "end_table"),
190                 'labellayer'    : ("start_labellayer",     None),
191                 'label'         : ("start_label",          None)})
192    
193      def start_session(self, name, qname, attrs):      def start_session(self, name, qname, attrs):
194          self.theSession = Session(attrs.get((None, 'title'), None))          self.theSession = Session(attrs.get((None, 'title'), None))
     start_dispatcher['session'] = "start_session"  
195    
196      def end_session(self, name, qname):      def end_session(self, name, qname):
197          pass          pass
     end_dispatcher['session'] = "end_session"  
198    
199      def start_map(self, name, qname, attrs):      def start_map(self, name, qname, attrs):
200          """Start a map."""          """Start a map."""
201          self.aMap = Map(attrs.get((None, 'title'), None))          self.aMap = Map(attrs.get((None, 'title'), None))
     start_dispatcher['map'] = "start_map"  
202    
203      def end_map(self, name, qname):      def end_map(self, name, qname):
204          self.theSession.AddMap(self.aMap)          self.theSession.AddMap(self.aMap)
     end_dispatcher['map'] = "end_map"  
205    
206      def start_projection(self, name, qname, attrs):      def start_projection(self, name, qname, attrs):
207          self.ProjectionParams = [ ]          self.ProjectionParams = [ ]
     start_dispatcher['projection'] = "start_projection"  
208    
209      def end_projection(self, name, qname):      def end_projection(self, name, qname):
210          self.aMap.SetProjection(Projection(self.ProjectionParams))          self.aMap.SetProjection(Projection(self.ProjectionParams))
     end_dispatcher['projection'] = "end_projection"  
211    
212      def start_parameter(self, name, qname, attrs):      def start_parameter(self, name, qname, attrs):
213          s = attrs.get((None, 'value'))          s = attrs.get((None, 'value'))
214          s = str(s) # we can't handle unicode in proj          s = str(s) # we can't handle unicode in proj
215          self.ProjectionParams.append(s)          self.ProjectionParams.append(s)
     start_dispatcher['parameter'] = "start_parameter"  
216    
217      def start_layer(self, name, qname, attrs, layer_class = Layer):      def start_layer(self, name, qname, attrs, layer_class = Layer):
218          """Start a layer          """Start a layer
# Line 149  class ProcessSession(xml.sax.handler.Con Line 223  class ProcessSession(xml.sax.handler.Con
223          """          """
224          title = attrs.get((None, 'title'), "")          title = attrs.get((None, 'title'), "")
225          filename = attrs.get((None, 'filename'), "")          filename = attrs.get((None, 'filename'), "")
226          filename = os.path.join(self.directory, filename)          filename = os.path.join(self.GetDirectory(), filename)
227          fill = parse_color(attrs.get((None, 'fill'), "None"))          fill = parse_color(attrs.get((None, 'fill'), "None"))
228          stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))          stroke = parse_color(attrs.get((None, 'stroke'), "#000000"))
229          stroke_width = int(attrs.get((None, 'stroke_width'), "1"))          stroke_width = int(attrs.get((None, 'stroke_width'), "1"))
230          self.aLayer = layer_class(title, filename, fill = fill,          self.aLayer = layer_class(title, filename, fill = fill,
231                                    stroke = stroke, lineWidth = stroke_width)                                    stroke = stroke, lineWidth = stroke_width)
     start_dispatcher['layer'] = "start_layer"  
232    
233      def end_layer(self, name, qname):      def end_layer(self, name, qname):
234          self.aMap.AddLayer(self.aLayer)          self.aMap.AddLayer(self.aLayer)
     end_dispatcher['layer'] = "end_layer"  
235    
236      def start_classification(self, name, qname, attrs):      def start_classification(self, name, qname, attrs):
237          field = attrs.get((None, 'field'), None)          field = attrs.get((None, 'field'), None)
# Line 181  class ProcessSession(xml.sax.handler.Con Line 253  class ProcessSession(xml.sax.handler.Con
253    
254          self.aLayer.GetClassification().SetField(field)          self.aLayer.GetClassification().SetField(field)
255    
     start_dispatcher['classification'] = "start_classification"  
256    
257      def end_classification(self, name, qname):      def end_classification(self, name, qname):
258          pass          pass
     end_dispatcher['classification'] = "end_classification"  
259    
260      def start_clnull(self, name, qname, attrs):      def start_clnull(self, name, qname, attrs):
261          self.cl_group = ClassGroupDefault()          self.cl_group = ClassGroupDefault()
262          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
263          self.cl_prop = ClassGroupProperties()          self.cl_prop = ClassGroupProperties()
     start_dispatcher['clnull'] = "start_clnull"  
264    
265      def end_clnull(self, name, qname):      def end_clnull(self, name, qname):
266          self.cl_group.SetProperties(self.cl_prop)          self.cl_group.SetProperties(self.cl_prop)
267          self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)          self.aLayer.GetClassification().SetDefaultGroup(self.cl_group)
268          del self.cl_group, self.cl_prop          del self.cl_group, self.cl_prop
     end_dispatcher['clnull'] = "end_clnull"  
269    
270      def start_clpoint(self, name, qname, attrs):      def start_clpoint(self, name, qname, attrs):
271          attrib_value = attrs.get((None, 'value'), "0")          attrib_value = attrs.get((None, 'value'), "0")
# Line 213  class ProcessSession(xml.sax.handler.Con Line 281  class ProcessSession(xml.sax.handler.Con
281          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
282          self.cl_prop = ClassGroupProperties()          self.cl_prop = ClassGroupProperties()
283    
     start_dispatcher['clpoint'] = "start_clpoint"  
284    
285      def end_clpoint(self, name, qname):      def end_clpoint(self, name, qname):
286          self.cl_group.SetProperties(self.cl_prop)          self.cl_group.SetProperties(self.cl_prop)
287          self.aLayer.GetClassification().AddGroup(self.cl_group)          self.aLayer.GetClassification().AppendGroup(self.cl_group)
288          del self.cl_group, self.cl_prop          del self.cl_group, self.cl_prop
     end_dispatcher['clpoint'] = "end_clpoint"  
289    
290      def start_clrange(self, name, qname, attrs):      def start_clrange(self, name, qname, attrs):
291    
# Line 235  class ProcessSession(xml.sax.handler.Con Line 301  class ProcessSession(xml.sax.handler.Con
301          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))          self.cl_group.SetLabel(attrs.get((None, 'label'), ""))
302          self.cl_prop = ClassGroupProperties()          self.cl_prop = ClassGroupProperties()
303    
     start_dispatcher['clrange'] = "start_clrange"  
304    
305      def end_clrange(self, name, qname):      def end_clrange(self, name, qname):
306          self.cl_group.SetProperties(self.cl_prop)          self.cl_group.SetProperties(self.cl_prop)
307          self.aLayer.GetClassification().AddGroup(self.cl_group)          self.aLayer.GetClassification().AppendGroup(self.cl_group)
308          del self.cl_group, self.cl_prop          del self.cl_group, self.cl_prop
     end_dispatcher['clrange'] = "end_clrange"  
309    
310      def start_cldata(self, name, qname, attrs):      def start_cldata(self, name, qname, attrs):
311          self.cl_prop.SetLineColor(          self.cl_prop.SetLineColor(
# Line 249  class ProcessSession(xml.sax.handler.Con Line 313  class ProcessSession(xml.sax.handler.Con
313          self.cl_prop.SetLineWidth(          self.cl_prop.SetLineWidth(
314              int(attrs.get((None, 'stroke_width'), "0")))              int(attrs.get((None, 'stroke_width'), "0")))
315          self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))          self.cl_prop.SetFill(parse_color(attrs.get((None, 'fill'), "None")))
     start_dispatcher['cldata'] = "start_cldata"  
316    
317      def end_cldata(self, name, qname):      def end_cldata(self, name, qname):
318          pass          pass
     end_dispatcher['cldata'] = "end_cldata"  
319    
320      def start_table(self, name, qname, attrs):      def start_table(self, name, qname, attrs):
321          #print "table title: %s" % attrs.get('title', None)          #print "table title: %s" % attrs.get('title', None)
322          pass          pass
     start_dispatcher['table'] = "start_table"  
323    
324      def end_table(self, name, qname):      def end_table(self, name, qname):
325          pass          pass
     end_dispatcher['table'] = "end_table"  
326    
327      def start_labellayer(self, name, qname, attrs):      def start_labellayer(self, name, qname, attrs):
328          self.aLayer = self.aMap.LabelLayer()          self.aLayer = self.aMap.LabelLayer()
     start_dispatcher['labellayer'] = "start_labellayer"  
329    
330      def start_label(self, name, qname, attrs):      def start_label(self, name, qname, attrs):
331          x = float(attrs[(None, 'x')])          x = float(attrs[(None, 'x')])
# Line 275  class ProcessSession(xml.sax.handler.Con Line 334  class ProcessSession(xml.sax.handler.Con
334          halign = attrs[(None, 'halign')]          halign = attrs[(None, 'halign')]
335          valign = attrs[(None, 'valign')]          valign = attrs[(None, 'valign')]
336          self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)          self.aLayer.AddLabel(x, y, text, halign = halign, valign = valign)
     start_dispatcher['label'] = "start_label"  
337    
338      def characters(self, chars):      def characters(self, chars):
339          pass          pass
# Line 283  class ProcessSession(xml.sax.handler.Con Line 341  class ProcessSession(xml.sax.handler.Con
341    
342  def load_session(filename):  def load_session(filename):
343      """Load a Thuban session from the file object file"""      """Load a Thuban session from the file object file"""
344      dir = os.path.dirname(filename)  
345      file = open(filename)      handler = SessionLoader()
346      handler = ProcessSession(dir)      handler.read(filename)
   
     parser = make_parser()  
     parser.setContentHandler(handler)  
     parser.setErrorHandler(ErrorHandler())  
     parser.setFeature(xml.sax.handler.feature_namespaces, 1)  
     parser.parse(file)  
347    
348      session = handler.theSession      session = handler.theSession
349      # Newly loaded session aren't modified      # Newly loaded session aren't modified
Legend:
Removed from v.493  
changed lines
  Added in v.706
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26