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

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

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

revision 428 by jonathan, Mon Feb 24 18:46:35 2003 UTC revision 462 by jonathan, Wed Mar 5 18:17:17 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2001 by Intevation GmbH  # Copyright (c) 2001, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Jonathan Coles <[email protected]>  # Jonathan Coles <[email protected]>
4  #  #
# Line 16  an input value falls with a range that d Line 16  an input value falls with a range that d
16  If no mapping can be found then default data will  If no mapping can be found then default data will
17  be returned. Input values must be hashable objects  be returned. Input values must be hashable objects
18    
19  See the description of GetClassData() for more information  See the description of GetGroup() for more information
20  on the mapping algorithm.  on the mapping algorithm.
21  """  """
22        
23  # fix for people using python2.1  # fix for people using python2.1
24  from __future__ import nested_scopes  from __future__ import nested_scopes
25    
26    from types import *
27    
28  from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \  from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
29       LAYER_VISIBILITY_CHANGED       LAYER_VISIBILITY_CHANGED
30    
31  from Thuban import _  from Thuban import _
32  from Thuban.Model.color import Color  from Thuban.Model.color import Color
33    
34  from wxPython.wx import *  import Thuban.Model.layer
35    
36    
37  # constants  # constants
38  RANGE_MIN  = 0  RANGE_MIN  = 0
# Line 37  RANGE_MAX  = 1 Line 40  RANGE_MAX  = 1
40  RANGE_DATA = 2  RANGE_DATA = 2
41    
42  class Classification:  class Classification:
43        """Encapsulates the classification of layer. The Classification
44        divides some kind of data into Groups which are associated with
45        properties. Later the properties can be retrieved by matching
46        data values to the appropriate group."""
47    
48      def __init__(self, layer = None, field = None):      def __init__(self, layer = None, field = None):
49          """Initialize a classification.          """Initialize a classification.
50    
51             layer -- the layer object who owns this classification             layer -- the Layer object who owns this classification
52    
53             field -- the name of the data table field that             field -- the name of the data table field that
54                      is to be used to classify layer properties                      is to be used to classify layer properties
55          """          """
56    
57          self.layer = layer          self.layer = None
58          self.points = {}          self.field = None
59          self.ranges = []          self.fieldType = None
60          self.maps   = []          self.groups = []
61          self.DefaultData = ClassDataDefault()          self.__sendMessages = False
62          self.field = field  
63          #self.SetField(field)          self.__ToggleMessages(False)
64            self.SetDefaultGroup(ClassGroupDefault())
65            self.SetLayer(layer)
66            self.SetField(field)
67    
68            self.__ToggleMessages(True)
69    
70      def __iter__(self):      def __iter__(self):
71          return ClassIterator(self.DefaultData,          return ClassIterator(self.groups)
72                               self.points.values(),  
73                               self.ranges,      def __ToggleMessages(self, on):
74                               self.maps)          self.__sendMessages = on
75    
76      def __SendMessage(self, message):      def __SendMessage(self, message):
77          if self.layer is not None:          """Send the message 'message' to the parent layer."""
78            if self.__sendMessages and self.layer is not None:
79              self.layer.changed(message, self.layer)              self.layer.changed(message, self.layer)
80            
81      def SetField(self, field):      def SetField(self, field = None):
82          """Set the name of the data table field to use.          """Set the name of the data table field to use.
83                    
84             field -- if None then all values map to the default data             field -- if None then all values map to the default data
85          """          """
86    
87            if field == "":
88                field = None
89    
90          self.field = field          self.field = field
91    
92            if self.layer is not None:
93                fieldType = self.layer.GetFieldType(field)
94            else:
95                fieldType = None
96    
97            self.SetFieldType(fieldType)
98    
99            # XXX: if fieldType comes back None then field isn't in the table!
100    
101          self.__SendMessage(LAYER_LEGEND_CHANGED)          self.__SendMessage(LAYER_LEGEND_CHANGED)
102    
103      def GetField(self):      def GetField(self):
104            """Return the name of the field."""
105          return self.field          return self.field
106    
107        def GetFieldType(self):
108            """Return the field type."""
109            return self.fieldType
110    
111        def SetFieldType(self, type):
112            self.fieldType = type
113    
114      def SetLayer(self, layer):      def SetLayer(self, layer):
115            """Set the owning Layer of this classification."""
116    
117            if __debug__:
118                if layer is not None:
119                    assert(isinstance(layer, Thuban.Model.layer.Layer))
120    
121          self.layer = layer          self.layer = layer
122            self.SetField(self.GetField()) # XXX: this sync's the fieldType
123    
124          self.__SendMessage(LAYER_LEGEND_CHANGED)          self.__SendMessage(LAYER_LEGEND_CHANGED)
125    
126      def GetLayer(self):      def GetLayer(self):
127          return layer.self          """Return the parent layer."""
128            return self.layer
129    
130      def SetDefaultData(self, data):      def SetDefaultGroup(self, group):
131          """Set the data to be used when a value can't be classified.          """Set the group to be used when a value can't be classified.
132    
133             data -- data that the value maps to. See class description.             group -- group that the value maps to.
134          """          """
135    
136          assert(data.GetType() == ClassData.DEFAULT)          assert(isinstance(group, ClassGroupDefault))
137          self.DefaultData = data          self.AddGroup(group)
138    
139      def GetDefaultData(self):      def GetDefaultGroup(self):
140          return self.DefaultData          """Return the default group."""
141            return self.groups[0]
142    
143      #      #
144      # these SetDefault* methods are really only provided for      # these SetDefault* methods are really only provided for
# Line 103  class Classification: Line 147  class Classification:
147      #      #
148    
149      def SetDefaultFill(self, fill):      def SetDefaultFill(self, fill):
150          self.DefaultData.SetFill(fill)          """Set the default fill color.
151    
152            fill -- a Color object.
153            """
154            assert(isinstance(fill, Color))
155            self.GetDefaultGroup().GetProperties().SetFill(fill)
156          self.__SendMessage(LAYER_LEGEND_CHANGED)          self.__SendMessage(LAYER_LEGEND_CHANGED)
157                    
158      def GetDefaultFill(self):      def GetDefaultFill(self):
159          return self.DefaultData.GetFill()          """Return the default fill color."""
160            return self.GetDefaultGroup().GetProperties().GetFill()
161                    
162      def SetDefaultStroke(self, stroke):      def SetDefaultLineColor(self, color):
163          self.DefaultData.SetStroke(stroke)          """Set the default line color.
164    
165            color -- a Color object.
166            """
167            assert(isinstance(color, Color))
168            self.GetDefaultGroup().GetProperties().SetLineColor(color)
169          self.__SendMessage(LAYER_LEGEND_CHANGED)          self.__SendMessage(LAYER_LEGEND_CHANGED)
170                    
171      def GetDefaultStroke(self):      def GetDefaultLineColor(self):
172          return self.DefaultData.GetStroke()          """Return the default line color."""
173            return self.GetDefaultGroup().GetProperties().GetLineColor()
174                    
175      def SetDefaultStrokeWidth(self, strokeWidth):      def SetDefaultLineWidth(self, lineWidth):
176          self.DefaultData.SetStrokeWidth(strokeWidth)          """Set the default line width.
177    
178            lineWidth -- an integer > 0.
179            """
180            assert(isinstance(lineWidth, IntType))
181            self.GetDefaultGroup().GetProperties().SetLineWidth(lineWidth)
182          self.__SendMessage(LAYER_LEGEND_CHANGED)          self.__SendMessage(LAYER_LEGEND_CHANGED)
183                    
184      def GetDefaultStrokeWidth(self):      def GetDefaultLineWidth(self):
185          return self.DefaultData.GetStrokeWidth()          """Return the default line width."""
186            return self.GetDefaultGroup().GetProperties().GetLineWidth()
187                    
188      def AddClassData(self, item):      def AddGroup(self, item):
189          type = item.GetType()          """Add a new ClassGroup item to the classification.
190    
191            item -- this must be a valid ClassGroup object
192            """
193    
194          if type == ClassData.POINT:          assert(isinstance(item, ClassGroup))
195              self.points[item.GetValue()] = item  
196          elif type == ClassData.RANGE:          if len(self.groups) > 0 and isinstance(item, ClassGroupDefault):
197              self.ranges.append(item)              self.groups[0] = item
198          elif type == ClassData.MAP:              #self.SetDefaultGroup(item)
             self.maps.append(item)  
         elif type == ClassData.DEFAULT:  
             self.DefaultData = item  
199          else:          else:
200              raise ValueError(_("Unrecognized ClassData type %s") % type)              self.groups.append(item)
201    
202          self.__SendMessage(LAYER_LEGEND_CHANGED)          self.__SendMessage(LAYER_LEGEND_CHANGED)
203    
204      def GetClassData(self, value):      def GetGroup(self, value):
205          """Return the associated data, or the default data.          """Return the associated group, or the default group.
206    
207             The following search technique is used:             Groups are checked in the order the were added to the
208                 (1) if the field is None, return the default data             Classification.
                (2) check if the value exists as a single value  
                (3) check if the value falls within a range. Ranges  
                    are checked in the order they were added to  
                    the classification.  
209    
210             value -- the value to classify. If there is no mapping,             value -- the value to classify. If there is no mapping,
211                      or value is None, return the default properties                      or value is None, return the default properties
212          """          """
213    
214          if self.field is not None and value is not None:          if self.field is not None and value is not None:
             #  
             # check the discrete values  
             #  
             if self.points.has_key(value):  
                 return self.points[value]  
   
             #  
             # check the ranges  
             #  
             for p in self.ranges:  
                 if p.InRange(value):  
                     return p  
   
             #  
             # check the maps  
             #  
             for p in self.maps:  
                 try:  
                     return p.Map(value)  
                 except: pass  
215    
216          return self.DefaultData              for i in range(1, len(self.groups)):
217                    group = self.groups[i]
218                    if group.Matches(value):
219                        return group
220    
221            return self.GetDefaultGroup()
222    
223        def GetProperties(self, value):
224            """Return the properties associated with the given value."""
225    
226            group = self.GetGroup(value)
227            if isinstance(group, ClassGroupMap):
228                return group.GetPropertiesFromValue(value)
229            else:
230                return group.GetProperties()
231    
232      def TreeInfo(self):      def TreeInfo(self):
233          items = []          items = []
# Line 188  class Classification: Line 240  class Classification:
240                      (text, color.red, color.green, color.blue),                      (text, color.red, color.green, color.blue),
241                      color)                      color)
242    
243          def build_item(data, string):          def build_item(group, string):
244              label = data.GetLabel()              label = group.GetLabel()
245              if label == "":              if label == "":
246                  label = string                  label = string
247              else:              else:
248                  label += " (%s)" % string                  label += " (%s)" % string
249    
250                props = group.GetProperties()
251              i = []              i = []
252              v = data.GetStroke()              v = props.GetLineColor()
253              i.append(build_color_item(_("Stroke"), v))              i.append(build_color_item(_("Line Color"), v))
254              v = data.GetStrokeWidth()              v = props.GetLineWidth()
255              i.append(_("Stroke Width: %s") % v)              i.append(_("Line Width: %s") % v)
256              v = data.GetFill()              v = props.GetFill()
257              i.append(build_color_item(_("Fill"), v))              i.append(build_color_item(_("Fill"), v))
258              return (label, i)              return (label, i)
259    
260          for p in self:          for p in self:
261              type = p.GetType()              if isinstance(p, ClassGroupDefault):
262              if type == ClassData.DEFAULT:                  items.append(build_item(self.GetDefaultGroup(), _("'DEFAULT'")))
263                  items.append(build_item(self.DefaultData, _("'DEFAULT'")))              elif isinstance(p, ClassGroupSingleton):
             elif type == ClassData.POINT:  
264                  items.append(build_item(p, str(p.GetValue())))                  items.append(build_item(p, str(p.GetValue())))
265              elif type == ClassData.RANGE:              elif isinstance(p, ClassGroupRange):
266                  items.append(build_item(p, "%s - %s" %                  items.append(build_item(p, "%s - %s" %
267                                             (p.GetMin(), p.GetMax())))                                             (p.GetMin(), p.GetMax())))
268    
269  #       for p in self.points.values():          return (_("Classification"), items)
270  #           items.append(build_item(p, str(p.GetValue())))  
271    class ClassIterator:
272        """Allows the Groups in a Classifcation to be interated over.
273    
274  #       for p in self.ranges:      The items are returned in the following order:
275  #           items.append(build_item(p, "%s - %s" % (p.GetMin(), p.GetMax())))          default data, singletons, ranges, maps
276        """
277    
278          return (_("Classifications"), items)      def __init__(self, data): #default, points, ranges, maps):
279            """Constructor.
280    
281            default -- the default group
282    
283  class ClassIterator:          points -- a list of singleton groups
284    
285            ranges -- a list of range groups
286    
287            maps -- a list of map groups
288            """
289    
290      def __init__(self, default, points, ranges, maps):          self.data = data #[default, points, ranges, maps]
291          self.data = [default, points, ranges, maps]          self.data_index = 0
292          self.data_iter = iter(self.data)          #self.data_iter = iter(self.data)
293          self.iter = None          #self.iter = None
294    
295      def __iter__(self):      def __iter__(self):
296          return self          return self
297    
298      def next(self):      def next(self):
299          if self.iter is None:          """Return the next item."""
300              try:  
301                  self.data_item = self.data_iter.next()          if self.data_index >= len(self.data):
302                  self.iter = iter(self.data_item)              raise StopIteration
303              except TypeError:          else:
304                  return self.data_item              d = self.data[self.data_index]
305                self.data_index += 1
306          try:              return d
307              return self.iter.next()          
308          except StopIteration:  #       if self.iter is None:
309              self.iter = None  #           try:
310              return self.next()  #               self.data_item = self.data_iter.next()
311    #               self.iter = iter(self.data_item)
312    #           except TypeError:
313    #               return self.data_item
314    
315    #       try:
316    #           return self.iter.next()
317    #       except StopIteration:
318    #           self.iter = None
319    #           return self.next()
320                
321  class ClassData:  class ClassGroupProperties:
322        """Represents the properties of a single Classification Group.
323      
324        These are used when rendering a layer."""
325    
326        def __init__(self, props = None):
327            """Constructor.
328    
329            props -- a ClassGroupProperties object. The class is copied if
330                     prop is not None. Otherwise, a default set of properties
331                     is created.
332            """
333    
334      INVALID = -1          self.stroke = None
335      DEFAULT = 0          self.strokeWidth = 0
336      POINT = 1          self.fill = None
337      RANGE = 2  
338      MAP   = 3          if props is not None:
339                self.SetProperties(props)
     def __init__(self, classData = None, type = INVALID):  
   
         if classData is not None:  
             self.SetStroke(classData.GetStroke())  
             self.SetStrokeWidth(classData.GetStrokeWidth())  
             self.SetFill(classData.GetFill())  
340          else:          else:
341              self.SetStroke(Color.None)              self.SetLineColor(Color.None)
342              self.SetStrokeWidth(1)              self.SetLineWidth(1)
343              self.SetFill(Color.None)              self.SetFill(Color.None)
344    
345          self.type = type      def SetProperties(self, props):
346          self.label = ""          """Set this class's properties to those in class props."""
       
     def GetType(self):  
         return self.type  
347    
348      def GetStroke(self):          assert(isinstance(props, ClassGroupProperties))
349            self.SetLineColor(props.GetLineColor())
350            self.SetLineWidth(props.GetLineWidth())
351            self.SetFill(props.GetFill())
352            
353        def GetLineColor(self):
354            """Return the line color as a Color object."""
355          return self.stroke          return self.stroke
356    
357      def SetStroke(self, stroke):      def SetLineColor(self, color):
358          assert(isinstance(stroke, Color))          """Set the line color.
         self.stroke = stroke  
   
     def GetStrokeWidth(self):  
         return self.stroke_width  
   
     def SetStrokeWidth(self, stroke_width):  
         if (stroke_width < 1):  
             raise ValueError(_("stroke_width < 1"))  
359    
360          self.stroke_width = stroke_width          color -- the color of the line. This must be a Color object.
361            """
362    
363            assert(isinstance(color, Color))
364            self.stroke = color
365    
366        def GetLineWidth(self):
367            """Return the line width."""
368            return self.strokeWidth
369    
370        def SetLineWidth(self, lineWidth):
371            """Set the line width.
372    
373            lineWidth -- the new line width. This must be > 0.
374            """
375            assert(isinstance(lineWidth, IntType))
376            if (lineWidth < 1):
377                raise ValueError(_("lineWidth < 1"))
378    
379            self.strokeWidth = lineWidth
380    
381      def GetFill(self):      def GetFill(self):
382            """Return the fill color as a Color object."""
383          return self.fill          return self.fill
384    
385      def SetFill(self, fill):      def SetFill(self, fill):
386            """Set the fill color.
387    
388            fill -- the color of the fill. This must be a Color object.
389            """
390    
391          assert(isinstance(fill, Color))          assert(isinstance(fill, Color))
392          self.fill = fill          self.fill = fill
393    
394    
395    class ClassGroup:
396        """A base class for all Groups within a Classification"""
397    
398        def __init__(self, label = ""):
399            """Constructor.
400    
401            label -- A string representing the Group's label
402            """
403    
404            self.label = None
405    
406            self.SetLabel(label)
407    
408      def GetLabel(self):      def GetLabel(self):
409            """Return the Group's label."""
410          return self.label          return self.label
411    
412      def SetLabel(self, label):      def SetLabel(self, label):
413            """Set the Group's label.
414    
415            label -- a string representing the Group's label. This must
416                     not be None.
417            """
418            assert(isinstance(label, StringType))
419          self.label = label          self.label = label
420    
421  class ClassDataDefault(ClassData):      def Matches(self, value):
422      def __init__(self, classData = None):          """Determines if this Group is associated with the given value.
423          ClassData.__init__(self, classData, ClassData.DEFAULT)  
424            Returns True or False. This needs to be implemented by all subclasses.
425            """
426            pass
427    
428        def GetProperties(self):
429            """Return the properties associated with the given value.
430    
431            This needs to be implemented by all subclasses.
432            """
433            pass
434    
435            
436  class ClassDataPoint(ClassData):  class ClassGroupSingleton(ClassGroup):
437        """A Group that is associated with a single value."""
438    
439      def __init__(self, value = 0, classData = None):      def __init__(self, value = 0, prop = None, label = ""):
440          ClassData.__init__(self, classData, ClassData.POINT)          """Constructor.
441    
442          self.value = value          value -- the associated value.
443    
444            prop -- a ClassGroupProperites object. If prop is None a default
445                     set of properties is created.
446    
447            label -- a label for this group.
448            """
449            ClassGroup.__init__(self, label)
450    
451            self.prop = None
452            self.value = None
453    
454            self.SetValue(value)
455            self.SetProperties(prop)
456    
457        def __copy__(self):
458            return ClassGroupSingleton(self.value, self.prop, self.label)
459    
460      def GetValue(self):      def GetValue(self):
461            """Return the associated value."""
462          return self.value          return self.value
463    
464      def SetValue(self, value):      def SetValue(self, value):
465            """Associate this Group with the given value."""
466          self.value = value          self.value = value
467    
468  class ClassDataRange(ClassData):      def Matches(self, value):
469            """Determine if the given value matches the associated Group value."""
470    
471      def __init__(self, min = 0, max = 1, classData = None):          """Returns True if the value matches, False otherwise."""
         ClassData.__init__(self, classData, ClassData.RANGE)  
472    
473          if min >= max:          return self.value == value
474              raise ValueError(_("ClassDataRange: %i(min) >= %i(max)!") %  
475                               (min, max))      def GetProperties(self):
476            """Return the Properties associated with this Group."""
477    
478            return self.prop
479    
480        def SetProperties(self, prop):
481            """Set the properties associated with this Group.
482    
483            prop -- a ClassGroupProperties object. if prop is None,
484                    a default set of properties is created.
485            """
486    
487            if prop is None: prop = ClassGroupProperties()
488            assert(isinstance(prop, ClassGroupProperties))
489            self.prop = prop
490    
491    
492    class ClassGroupDefault(ClassGroupSingleton):
493        """The default Group. When values do not match any other
494           Group within a Classification, the properties from this
495           class are used."""
496    
497        def __init__(self, prop = None, label = ""):
498            """Constructor.
499    
500            prop -- a ClassGroupProperites object. If prop is None a default
501                     set of properties is created.
502    
503            label -- a label for this group.
504            """
505    
506            ClassGroupSingleton.__init__(self, 0, prop, label)
507    
508        def __copy__(self):
509            return ClassGroupDefault(self.prop, self.label)
510    
511        def GetProperties(self):
512            """Return the Properties associated with this Group."""
513            return self.prop
514    
515    class ClassGroupRange(ClassGroup):
516        """A Group that represents a range of values that map to the same
517           set of properties."""
518    
519        def __init__(self, min = 0, max = 1, prop = None, label = ""):
520            """Constructor.
521    
522            The minumum value must be strictly less than the maximum.
523    
524            min -- the minimum range value
525    
526            max -- the maximum range value
527    
528            prop -- a ClassGroupProperites object. If prop is None a default
529                     set of properties is created.
530    
531            label -- a label for this group.
532            """
533    
534            ClassGroup.__init__(self, label)
535    
536            self.min = self.max = 0
537            self.prop = None
538    
539          self.SetRange(min, max)          self.SetRange(min, max)
540            self.SetProperties(prop)
541    
542        def __copy__(self):
543            return ClassGroupRange(self.min, self.max, self.prop, self.label)
544    
545      def GetMin(self):      def GetMin(self):
546            """Return the range's minimum value."""
547          return self.min          return self.min
548    
549      def SetMin(self, min):      def SetMin(self, min):
550            """Set the range's minimum value.
551        
552            min -- the new minimum. Note that this must be less than the current
553                   maximum value. Use SetRange() to change both min and max values.
554            """
555        
556          self.SetRange(min, self.max)          self.SetRange(min, self.max)
557    
558      def GetMax(self):      def GetMax(self):
559            """Return the range's maximum value."""
560          return self.max          return self.max
561    
562      def SetMax(self, max):      def SetMax(self, max):
563            """Set the range's maximum value.
564        
565            max -- the new maximum. Note that this must be greater than the current
566                   minimum value. Use SetRange() to change both min and max values.
567            """
568          self.SetRange(self.min, max)          self.SetRange(self.min, max)
569    
570      def SetRange(self, min, max):      def SetRange(self, min, max):
571          self.min = min          """Set a new range.
572          self.max = max  
573            Note that min must be strictly less than max.
574    
575            min -- the new minimum value
576            min -- the new maximum value
577            """
578    
579          if min >= max:          if min >= max:
580              raise ValueError(_("ClassDataRange: %i(min) >= %i(max)!") %              raise ValueError(_("ClassGroupRange: %i(min) >= %i(max)!") %
581                               (min, max))                               (min, max))
582            self.min = min
583            self.max = max
584    
585      def GetRange(self):      def GetRange(self):
586            """Return the range as a tuple (min, max)"""
587          return (self.min, self.max)          return (self.min, self.max)
588    
589      def InRange(self, value):      def Matches(self, value):
590            """Determine if the given value lies with the current range.
591    
592            The following check is used: min <= value < max.
593            """
594    
595          return self.min <= value < self.max          return self.min <= value < self.max
596    
597  class ClassDataMap(ClassData):      def GetProperties(self):
598            """Return the Properties associated with this Group."""
599            return self.prop
600    
601        def SetProperties(self, prop):
602            """Set the properties associated with this Group.
603    
604            prop -- a ClassGroupProperties object. if prop is None,
605                    a default set of properties is created.
606            """
607            if prop is None: prop = ClassGroupProperties()
608            assert(isinstance(prop, ClassGroupProperties))
609            self.prop = prop
610    
611    class ClassGroupMap(ClassGroup):
612        """Currently, this class is not used."""
613    
614      FUNC_ID = "id"      FUNC_ID = "id"
615    
616      def __init__(self, map_type = FUNC_ID, func = None, classData = None):      def __init__(self, map_type = FUNC_ID, func = None, prop = None, label=""):
617          ClassData.__init__(self, classData, ClassData.MAP)          ClassGroup.__init__(self, label)
618    
619          self.map_type = map_type          self.map_type = map_type
620          self.func = func          self.func = func
# Line 369  class ClassDataMap(ClassData): Line 625  class ClassDataMap(ClassData):
625      def Map(self, value):      def Map(self, value):
626          return self.func(value)          return self.func(value)
627    
628        def GetProperties(self):
629            return None
630    
631        def GetPropertiesFromValue(self, value):
632            pass
633    
634      #      #
635      # built-in mappings      # built-in mappings
636      #      #
Legend:
Removed from v.428  
changed lines
  Added in v.462
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26