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