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

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

Parent Directory | Revision Log | View Patch Patch

-revision 462 by jonathan,
Wed Mar  5 18:17:17 2003 UTC
+revision 2657 by jan,
Wed Jul 27 21:49:25 2005 UTC
 Line 1
- # Copyright (c) 2001, 2003 by Intevation GmbH
+ # Copyright (c) 2001, 2003, 2005 by Intevation GmbH
  # Authors:
  # Jonathan Coles <[email protected]>
+ # Jan-Oliver Wagner <[email protected]> (2005)
  #
  # This program is free software under the GPL (>=v2)
  # Read the file COPYING coming with Thuban for details.
-Line 16 
 an input value falls with a range that d
+Line 17 
 an input value falls with a range that d
  If no mapping can be found then default data will
  be returned. Input values must be hashable objects
- See the description of GetGroup() for more information
+ See the description of FindGroup() for more information
  on the mapping algorithm.
  """
- # fix for people using python2.1
+ import copy, operator, types
- from __future__ import nested_scopes
- from types import *
- from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
-      LAYER_VISIBILITY_CHANGED
  from Thuban import _
- from Thuban.Model.color import Color
- import Thuban.Model.layer
+ from messages import \
+     LAYER_PROJECTION_CHANGED, \
+     LAYER_LEGEND_CHANGED, \
+     LAYER_VISIBILITY_CHANGED,\
+     CLASS_CHANGED
+ from Thuban.Model.color import Color, Transparent, Black
+ from Thuban.Model.range import Range
- # constants
+ import Thuban.Model.layer
- RANGE_MIN  = 0
- RANGE_MAX  = 1
- RANGE_DATA = 2
- class Classification:
-     """Encapsulates the classification of layer. The Classification
-     divides some kind of data into Groups which are associated with
-     properties. Later the properties can be retrieved by matching
-     data values to the appropriate group."""
-     def __init__(self, layer = None, field = None):
+ from Thuban.Lib.connector import Publisher
-         """Initialize a classification.
-            layer -- the Layer object who owns this classification
+ class Classification(Publisher):
+     """Encapsulates the classification of layer.
+     The Classification divides some kind of data into Groups which
+     are associated with properties. Later the properties can be
+     retrieved by matching data values to the appropriate group.
+     """
-            field -- the name of the data table field that
+     def __init__(self):
-                     is to be used to classify layer properties
+         """Initialize a classification."""
-         """
-         self.layer = None
+         self.__groups = []
-         self.field = None
-         self.fieldType = None
-         self.groups = []
-         self.__sendMessages = False
-         self.__ToggleMessages(False)
          self.SetDefaultGroup(ClassGroupDefault())
-         self.SetLayer(layer)
-         self.SetField(field)
-         self.__ToggleMessages(True)
      def __iter__(self):
-         return ClassIterator(self.groups)
+         return ClassIterator(self.__groups)
-     def __ToggleMessages(self, on):
-         self.__sendMessages = on
-     def __SendMessage(self, message):
-         """Send the message 'message' to the parent layer."""
-         if self.__sendMessages and self.layer is not None:
-             self.layer.changed(message, self.layer)
-     def SetField(self, field = None):
-         """Set the name of the data table field to use.
-            field -- if None then all values map to the default data
-         """
-         if field == "":
-             field = None
-         self.field = field
-         if self.layer is not None:
-             fieldType = self.layer.GetFieldType(field)
-         else:
-             fieldType = None
-         self.SetFieldType(fieldType)
-         # XXX: if fieldType comes back None then field isn't in the table!
-         self.__SendMessage(LAYER_LEGEND_CHANGED)
+     def __deepcopy__(self, memo):
+         clazz = Classification()
-     def GetField(self):
+         clazz.__groups[0] = copy.deepcopy(self.__groups[0])
-         """Return the name of the field."""
-         return self.field
-     def GetFieldType(self):
+         for i in range(1, len(self.__groups)):
-         """Return the field type."""
+             clazz.__groups.append(copy.deepcopy(self.__groups[i]))
-         return self.fieldType
+         return clazz
-     def SetFieldType(self, type):
-         self.fieldType = type
+     def __SendNotification(self):
+         """Notify the layer that this class has changed."""
-     def SetLayer(self, layer):
+         self.issue(CLASS_CHANGED)
-         """Set the owning Layer of this classification."""
+     def __getattr__(self, attr):
-         if __debug__:
+         """Generate the compiled classification on demand"""
-             if layer is not None:
+         if attr == "_compiled_classification":
-                 assert(isinstance(layer, Thuban.Model.layer.Layer))
+             self._compile_classification()
+             return self._compiled_classification
-         self.layer = layer
+         raise AttributeError(attr)
-         self.SetField(self.GetField()) # XXX: this sync's the fieldType
+     def _compile_classification(self):
-         self.__SendMessage(LAYER_LEGEND_CHANGED)
+         """Generate the compiled classification
+         The compiled classification is a more compact representation of
+         the classification groups that is also more efficient for
+         performing the classification.
+         The compiled classification is a list of tuples. The first
+         element of the tuple is a string which describes the rest of the
+         tuple. There are two kinds of tuples:
+           'singletons'
+             The second element of the tuple is a dictionary which
+             combines several consecutive ClassGroupSingleton instances.
+             The dictionary maps the values of the singletons (as
+             returned by the GetValue() method) to the corresponding
+             group.
+           'range'
+             The tuple describes a ClassGroupRange instance. The tuples
+             second element is a tuple fo the form (lfunc, min, max,
+             rfunc, group) where group is the original group object,
+             lfunc and rfuct are comparison functions and min and max are
+             lower and upper bounds of the range. Given a value and such
+             a tuple the group matches if and only if
+                 lfunc(min, value) and rfunc(max, value)
+             is true.
+         The compiled classification is bound to
+         self._compile_classification.
+         """
+         compiled = []
+         for group in self.__groups[1:]:
+             if isinstance(group, ClassGroupSingleton):
+                 if not compiled or compiled[-1][0] != "singletons":
+                     compiled.append(("singletons", {}))
+                 compiled[-1][1].setdefault(group.GetValue(), group)
+             elif isinstance(group, ClassGroupRange):
+                 left, min, max, right = group.GetRangeTuple()
+                 if left == "[":
+                     lfunc = operator.le
+                 elif left == "]":
+                     lfunc = operator.lt
+                 if right == "[":
+                     rfunc = operator.gt
+                 elif right == "]":
+                     rfunc = operator.ge
+                 compiled.append(("range", (lfunc, min, max, rfunc, group)))
+             else:
+                 raise TypeError("Unknown group type %s", group)
+         self._compiled_classification = compiled
-     def GetLayer(self):
+     def _clear_compiled_classification(self):
-         """Return the parent layer."""
+         """Reset the compiled classification.
-         return self.layer
-     def SetDefaultGroup(self, group):
+         If will be created on demand when self._compiled_classification
-         """Set the group to be used when a value can't be classified.
+         is accessed again.
-            group -- group that the value maps to.
+         Call this method whenever self.__groups is modified.
          """
+         try:
-         assert(isinstance(group, ClassGroupDefault))
+             del self._compiled_classification
-         self.AddGroup(group)
+         except:
+             pass
-     def GetDefaultGroup(self):
-         """Return the default group."""
-         return self.groups[0]
      #
      # these SetDefault* methods are really only provided for
-Line 151 
 class Classification:
+Line 157 
 class Classification:
          fill -- a Color object.
          """
-         assert(isinstance(fill, Color))
          self.GetDefaultGroup().GetProperties().SetFill(fill)
-         self.__SendMessage(LAYER_LEGEND_CHANGED)
+         self.__SendNotification()
      def GetDefaultFill(self):
          """Return the default fill color."""
-Line 164 
 class Classification:
+Line 169 
 class Classification:
          color -- a Color object.
          """
-         assert(isinstance(color, Color))
          self.GetDefaultGroup().GetProperties().SetLineColor(color)
-         self.__SendMessage(LAYER_LEGEND_CHANGED)
+         self.__SendNotification()
      def GetDefaultLineColor(self):
          """Return the default line color."""
-Line 177 
 class Classification:
+Line 181 
 class Classification:
          lineWidth -- an integer > 0.
          """
-         assert(isinstance(lineWidth, IntType))
+         assert isinstance(lineWidth, types.IntType)
          self.GetDefaultGroup().GetProperties().SetLineWidth(lineWidth)
-         self.__SendMessage(LAYER_LEGEND_CHANGED)
+         self.__SendNotification()
      def GetDefaultLineWidth(self):
          """Return the default line width."""
          return self.GetDefaultGroup().GetProperties().GetLineWidth()
-     def AddGroup(self, item):
-         """Add a new ClassGroup item to the classification.
-         item -- this must be a valid ClassGroup object
+     #
-         """
+     # The methods that manipulate self.__groups have to be kept in
+     # sync. We store the default group in index 0 to make it
+     # convienent to iterate over the classification's groups, but
+     # from the user's perspective the first (non-default) group is
+     # at index 0 and the DefaultGroup is a special entity.
+     #
-         assert(isinstance(item, ClassGroup))
+     def SetDefaultGroup(self, group):
+         """Set the group to be used when a value can't be classified.
-         if len(self.groups) > 0 and isinstance(item, ClassGroupDefault):
+         group -- group that the value maps to.
-             self.groups[0] = item
+         """
-             #self.SetDefaultGroup(item)
+         assert isinstance(group, ClassGroupDefault)
+         if len(self.__groups) > 0:
+             self.__groups[0] = group
          else:
-             self.groups.append(item)
+             self.__groups.append(group)
+         self.__SendNotification()
-         self.__SendMessage(LAYER_LEGEND_CHANGED)
-     def GetGroup(self, value):
+     def GetDefaultGroup(self):
-         """Return the associated group, or the default group.
+         """Return the default group."""
+         return self.__groups[0]
-            Groups are checked in the order the were added to the
+     def AppendGroup(self, item):
-            Classification.
+         """Append a new ClassGroup item to the classification.
-            value -- the value to classify. If there is no mapping,
+         item -- this must be a valid ClassGroup object
-                     or value is None, return the default properties
          """
-         if self.field is not None and value is not None:
+         self.InsertGroup(self.GetNumGroups(), item)
-             for i in range(1, len(self.groups)):
+     def InsertGroup(self, index, group):
-                 group = self.groups[i]
+         assert isinstance(group, ClassGroup)
-                 if group.Matches(value):
+         self.__groups.insert(index + 1, group)
-                     return group
+         self._clear_compiled_classification()
+         self.__SendNotification()
+     def RemoveGroup(self, index):
+         """Remove the classification group with the given index"""
+         self.__groups.pop(index + 1)
+         self._clear_compiled_classification()
+         self.__SendNotification()
+     def ReplaceGroup(self, index, group):
+         assert isinstance(group, ClassGroup)
+         self.__groups[index + 1] = group
+         self._clear_compiled_classification()
+         self.__SendNotification()
+     def GetGroup(self, index):
+         return self.__groups[index + 1]
+     def GetNumGroups(self):
+         """Return the number of non-default groups in the classification."""
+         return len(self.__groups) - 1
+     def FindGroup(self, value):
+         """Return the group that matches the value.
+         Groups are effectively checked in the order the were added to
+         the Classification.
+         value -- the value to classify. If there is no mapping or value
+                  is None, return the default properties
+         """
+         if value is not None:
+             for typ, params in self._compiled_classification:
+                 if typ == "singletons":
+                     group = params.get(value)
+                     if group is not None:
+                         return group
+                 elif typ == "range":
+                     lfunc, min, max, rfunc, g = params
+                     if lfunc(min, value) and rfunc(max, value):
+                         return g
          return self.GetDefaultGroup()
      def GetProperties(self, value):
-         """Return the properties associated with the given value."""
+         """Return the properties associated with the given value.
+         Use this function rather than Classification.FindGroup().GetProperties()
+         since the returned group may be a ClassGroupMap which doesn't support
+         a call to GetProperties().
+         """
-         group = self.GetGroup(value)
+         group = self.FindGroup(value)
          if isinstance(group, ClassGroupMap):
              return group.GetPropertiesFromValue(value)
          else:
-Line 233 
 class Classification:
+Line 288 
 class Classification:
          items = []
          def build_color_item(text, color):
-             if color is Color.None:
+             if color is Transparent:
                  return ("%s: %s" % (text, _("None")), None)
              return ("%s: (%.3f, %.3f, %.3f)" %
-Line 253 
 class Classification:
+Line 308 
 class Classification:
              i.append(build_color_item(_("Line Color"), v))
              v = props.GetLineWidth()
              i.append(_("Line Width: %s") % v)
+             # Note: Size is owned by all properties, so
+             # a size will also appear where it does not
+             # make sense like for lines and polygons.
+             v = props.GetSize()
+             i.append(_("Size: %s") % v)
              v = props.GetFill()
              i.append(build_color_item(_("Fill"), v))
              return (label, i)
          for p in self:
-             if isinstance(p, ClassGroupDefault):
+             items.append(build_item(p, p.GetDisplayText()))
-                 items.append(build_item(self.GetDefaultGroup(), _("'DEFAULT'")))
-             elif isinstance(p, ClassGroupSingleton):
-                 items.append(build_item(p, str(p.GetValue())))
-             elif isinstance(p, ClassGroupRange):
-                 items.append(build_item(p, "%s - %s" %
-                                            (p.GetMin(), p.GetMax())))
          return (_("Classification"), items)
  class ClassIterator:
      """Allows the Groups in a Classifcation to be interated over.
-Line 279 
 class ClassIterator:
+Line 335 
 class ClassIterator:
          """Constructor.
          default -- the default group
          points -- a list of singleton groups
          ranges -- a list of range groups
          maps -- a list of map groups
          """
-         self.data = data #[default, points, ranges, maps]
+         self.data = data
          self.data_index = 0
-         #self.data_iter = iter(self.data)
-         #self.iter = None
      def __iter__(self):
          return self
-Line 304 
 class ClassIterator:
+Line 358 
 class ClassIterator:
              d = self.data[self.data_index]
              self.data_index += 1
              return d
- #       if self.iter is None:
- #           try:
- #               self.data_item = self.data_iter.next()
- #               self.iter = iter(self.data_item)
- #           except TypeError:
- #               return self.data_item
- #       try:
- #           return self.iter.next()
- #       except StopIteration:
- #           self.iter = None
- #           return self.next()
  class ClassGroupProperties:
      """Represents the properties of a single Classification Group.
      These are used when rendering a layer."""
+     # TODO: Actually, size is only relevant for point objects.
+     # Eventually it should be spearated, e.g. when introducing symbols.
      def __init__(self, props = None):
          """Constructor.
          props -- a ClassGroupProperties object. The class is copied if
                   prop is not None. Otherwise, a default set of properties
-                  is created.
+                  is created such that: line color = Black, line width = 1,
+                  size = 5 and fill color = Transparent
          """
-         self.stroke = None
-         self.strokeWidth = 0
-         self.fill = None
          if props is not None:
              self.SetProperties(props)
          else:
-             self.SetLineColor(Color.None)
+             self.SetLineColor(Black)
              self.SetLineWidth(1)
-             self.SetFill(Color.None)
+             self.SetSize(5)
+             self.SetFill(Transparent)
      def SetProperties(self, props):
          """Set this class's properties to those in class props."""
-         assert(isinstance(props, ClassGroupProperties))
+         assert isinstance(props, ClassGroupProperties)
          self.SetLineColor(props.GetLineColor())
          self.SetLineWidth(props.GetLineWidth())
+         self.SetSize(props.GetSize())
          self.SetFill(props.GetFill())
      def GetLineColor(self):
          """Return the line color as a Color object."""
-         return self.stroke
+         return self.__stroke
      def SetLineColor(self, color):
          """Set the line color.
-Line 360 
 class ClassGroupProperties:
+Line 403 
 class ClassGroupProperties:
          color -- the color of the line. This must be a Color object.
          """
-         assert(isinstance(color, Color))
+         self.__stroke = color
-         self.stroke = color
      def GetLineWidth(self):
          """Return the line width."""
-         return self.strokeWidth
+         return self.__strokeWidth
      def SetLineWidth(self, lineWidth):
          """Set the line width.
          lineWidth -- the new line width. This must be > 0.
          """
-         assert(isinstance(lineWidth, IntType))
+         assert isinstance(lineWidth, types.IntType)
          if (lineWidth < 1):
              raise ValueError(_("lineWidth < 1"))
-         self.strokeWidth = lineWidth
+         self.__strokeWidth = lineWidth
+     def GetSize(self):
+         """Return the size."""
+         return self.__size
+     def SetSize(self, size):
+         """Set the size.
+         size -- the new size. This must be > 0.
+         """
+         assert isinstance(size, types.IntType)
+         if (size < 1):
+             raise ValueError(_("size < 1"))
+         self.__size = size
      def GetFill(self):
          """Return the fill color as a Color object."""
-         return self.fill
+         return self.__fill
      def SetFill(self, fill):
          """Set the fill color.
          fill -- the color of the fill. This must be a Color object.
          """
-         assert(isinstance(fill, Color))
+         self.__fill = fill
-         self.fill = fill
+     def __eq__(self, other):
+         """Return true if 'props' has the same attributes as this class"""
+         #
+         # using 'is' over '==' results in a huge performance gain
+         # in the renderer
+         #
+         return isinstance(other, ClassGroupProperties)   \
+             and (self.__stroke is other.__stroke or      \
+                  self.__stroke == other.__stroke)        \
+             and (self.__fill is other.__fill or          \
+                  self.__fill == other.__fill)            \
+             and self.__strokeWidth == other.__strokeWidth\
+             and self.__size == other.__size
+     def __ne__(self, other):
+         return not self.__eq__(other)
+     def __copy__(self):
+         return ClassGroupProperties(self)
+     def __deepcopy__(self):
+         return ClassGroupProperties(self)
+     def __repr__(self):
+         return repr((self.__stroke, self.__strokeWidth, self.__size,
+                     self.__fill))
  class ClassGroup:
      """A base class for all Groups within a Classification"""
-     def __init__(self, label = ""):
+     def __init__(self, label = "", props = None, group = None):
          """Constructor.
          label -- A string representing the Group's label
          """
-         self.label = None
+         if group is not None:
+             self.SetLabel(copy.copy(group.GetLabel()))
-         self.SetLabel(label)
+             self.SetProperties(copy.copy(group.GetProperties()))
+             self.SetVisible(group.IsVisible())
+         else:
+             self.SetLabel(label)
+             self.SetProperties(props)
+             self.SetVisible(True)
      def GetLabel(self):
          """Return the Group's label."""
          return self.label
      def SetLabel(self, label):
          """Set the Group's label.
          label -- a string representing the Group's label. This must
                   not be None.
          """
-         assert(isinstance(label, StringType))
+         assert isinstance(label, types.StringTypes)
          self.label = label
+     def GetDisplayText(self):
+         assert False, "GetDisplay must be overridden by subclass!"
+         return ""
      def Matches(self, value):
          """Determines if this Group is associated with the given value.
-         Returns True or False. This needs to be implemented by all subclasses.
+         Returns False. This needs to be overridden by all subclasses.
          """
-         pass
+         assert False, "GetMatches must be overridden by subclass!"
+         return False
      def GetProperties(self):
-         """Return the properties associated with the given value.
+         """Return the properties associated with the given value."""
-         This needs to be implemented by all subclasses.
+         return self.prop
-         """
-         pass
+     def SetProperties(self, prop):
+         """Set the properties associated with this Group.
+         prop -- a ClassGroupProperties object. if prop is None,
+                 a default set of properties is created.
+         """
+         if prop is None: prop = ClassGroupProperties()
+         assert isinstance(prop, ClassGroupProperties)
+         self.prop = prop
+     def IsVisible(self):
+         return self.visible
+     def SetVisible(self, visible):
+         self.visible = visible
+     def __eq__(self, other):
+         return isinstance(other, ClassGroup) \
+             and self.label == other.label \
+             and self.GetProperties() == other.GetProperties()
+     def __ne__(self, other):
+         return not self.__eq__(other)
+     def __repr__(self):
+         return repr(self.label) + ", " + repr(self.GetProperties())
  class ClassGroupSingleton(ClassGroup):
      """A Group that is associated with a single value."""
-     def __init__(self, value = 0, prop = None, label = ""):
+     def __init__(self, value = 0, props = None, label = "", group = None):
          """Constructor.
          value -- the associated value.
-Line 446 
 class ClassGroupSingleton(ClassGroup):
+Line 564 
 class ClassGroupSingleton(ClassGroup):
          label -- a label for this group.
          """
-         ClassGroup.__init__(self, label)
+         ClassGroup.__init__(self, label, props, group)
-         self.prop = None
-         self.value = None
          self.SetValue(value)
-         self.SetProperties(prop)
      def __copy__(self):
-         return ClassGroupSingleton(self.value, self.prop, self.label)
+         return ClassGroupSingleton(self.GetValue(),
+                                    self.GetProperties(),
+                                    self.GetLabel())
+     def __deepcopy__(self, memo):
+         return ClassGroupSingleton(self.GetValue(), group = self)
      def GetValue(self):
          """Return the associated value."""
-         return self.value
+         return self.__value
      def SetValue(self, value):
          """Associate this Group with the given value."""
-         self.value = value
+         self.__value = value
      def Matches(self, value):
          """Determine if the given value matches the associated Group value."""
          """Returns True if the value matches, False otherwise."""
-         return self.value == value
+         return self.__value == value
-     def GetProperties(self):
+     def GetDisplayText(self):
-         """Return the Properties associated with this Group."""
+         label = self.GetLabel()
-         return self.prop
+         if label != "": return label
-     def SetProperties(self, prop):
+         return str(self.GetValue())
-         """Set the properties associated with this Group.
-         prop -- a ClassGroupProperties object. if prop is None,
+     def __eq__(self, other):
-                 a default set of properties is created.
+         return ClassGroup.__eq__(self, other) \
-         """
+             and isinstance(other, ClassGroupSingleton) \
+             and self.__value == other.__value
-         if prop is None: prop = ClassGroupProperties()
-         assert(isinstance(prop, ClassGroupProperties))
-         self.prop = prop
+     def __repr__(self):
+         return "(" + repr(self.__value) + ", " + ClassGroup.__repr__(self) + ")"
- class ClassGroupDefault(ClassGroupSingleton):
+ class ClassGroupDefault(ClassGroup):
      """The default Group. When values do not match any other
         Group within a Classification, the properties from this
         class are used."""
-     def __init__(self, prop = None, label = ""):
+     def __init__(self, props = None, label = "", group = None):
          """Constructor.
          prop -- a ClassGroupProperites object. If prop is None a default
-Line 503 
 class ClassGroupDefault(ClassGroupSingle
+Line 620 
 class ClassGroupDefault(ClassGroupSingle
          label -- a label for this group.
          """
-         ClassGroupSingleton.__init__(self, 0, prop, label)
+         ClassGroup.__init__(self, label, props, group)
      def __copy__(self):
-         return ClassGroupDefault(self.prop, self.label)
+         return ClassGroupDefault(self.GetProperties(), self.GetLabel())
-     def GetProperties(self):
+     def __deepcopy__(self, memo):
-         """Return the Properties associated with this Group."""
+         return ClassGroupDefault(label = self.GetLabel(), group = self)
-         return self.prop
+     def Matches(self, value):
+         return True
+     def GetDisplayText(self):
+         label = self.GetLabel()
+         if label != "": return label
+         return _("DEFAULT")
+     def __eq__(self, other):
+         return ClassGroup.__eq__(self, other) \
+             and isinstance(other, ClassGroupDefault) \
+             and self.GetProperties() == other.GetProperties()
+     def __repr__(self):
+         return "(" + ClassGroup.__repr__(self) + ")"
  class ClassGroupRange(ClassGroup):
      """A Group that represents a range of values that map to the same
         set of properties."""
-     def __init__(self, min = 0, max = 1, prop = None, label = ""):
+     def __init__(self, _range = (0,1), props = None, label = "", group=None):
          """Constructor.
          The minumum value must be strictly less than the maximum.
-         min -- the minimum range value
+         _range -- either a tuple (min, max) where min < max or
+                   a Range object
-         max -- the maximum range value
          prop -- a ClassGroupProperites object. If prop is None a default
                   set of properties is created.
-Line 531 
 class ClassGroupRange(ClassGroup):
+Line 664 
 class ClassGroupRange(ClassGroup):
          label -- a label for this group.
          """
-         ClassGroup.__init__(self, label)
+         ClassGroup.__init__(self, label, props, group)
+         self.SetRange(_range)
-         self.min = self.max = 0
-         self.prop = None
-         self.SetRange(min, max)
-         self.SetProperties(prop)
      def __copy__(self):
-         return ClassGroupRange(self.min, self.max, self.prop, self.label)
+         return ClassGroupRange(self.__range,
+                                props = self.GetProperties(),
+                                label = self.GetLabel())
+     def __deepcopy__(self, memo):
+         return ClassGroupRange(copy.copy(self.__range),
+                                group = self)
      def GetMin(self):
          """Return the range's minimum value."""
-         return self.min
+         return self.__range.GetRange()[1]
      def SetMin(self, min):
          """Set the range's minimum value.
-Line 553 
 class ClassGroupRange(ClassGroup):
+Line 687 
 class ClassGroupRange(ClassGroup):
                 maximum value. Use SetRange() to change both min and max values.
          """
-         self.SetRange(min, self.max)
+         self.SetRange((min, self.__range.GetRange()[2]))
      def GetMax(self):
          """Return the range's maximum value."""
-         return self.max
+         return self.__range.GetRange()[2]
      def SetMax(self, max):
          """Set the range's maximum value.
-Line 565 
 class ClassGroupRange(ClassGroup):
+Line 699 
 class ClassGroupRange(ClassGroup):
          max -- the new maximum. Note that this must be greater than the current
                 minimum value. Use SetRange() to change both min and max values.
          """
-         self.SetRange(self.min, max)
+         self.SetRange((self.__range.GetRange()[1], max))
-     def SetRange(self, min, max):
+     def SetRange(self, _range):
          """Set a new range.
-         Note that min must be strictly less than max.
+         _range -- Either a tuple (min, max) where min < max or
+                   a Range object.
-         min -- the new minimum value
+         Raises ValueError on error.
-         min -- the new maximum value
          """
-         if min >= max:
+         if isinstance(_range, Range):
-             raise ValueError(_("ClassGroupRange: %i(min) >= %i(max)!") %
+             self.__range = _range
-                              (min, max))
+         elif isinstance(_range, types.TupleType) and len(_range) == 2:
-         self.min = min
+             self.__range = Range(("[", _range[0], _range[1], "["))
-         self.max = max
+         else:
+             raise ValueError()
      def GetRange(self):
-         """Return the range as a tuple (min, max)"""
+         """Return the range as a string"""
-         return (self.min, self.max)
+         return self.__range.string(self.__range.GetRange())
+     def GetRangeTuple(self):
+         return self.__range.GetRange()
      def Matches(self, value):
          """Determine if the given value lies with the current range.
-Line 592 
 class ClassGroupRange(ClassGroup):
+Line 730 
 class ClassGroupRange(ClassGroup):
          The following check is used: min <= value < max.
          """
-         return self.min <= value < self.max
+         return operator.contains(self.__range, value)
-     def GetProperties(self):
+     def GetDisplayText(self):
-         """Return the Properties associated with this Group."""
+         label = self.GetLabel()
-         return self.prop
-     def SetProperties(self, prop):
+         if label != "": return label
-         """Set the properties associated with this Group.
-         prop -- a ClassGroupProperties object. if prop is None,
+         return self.__range.string(self.__range.GetRange())
-                 a default set of properties is created.
-         """
+     def __eq__(self, other):
-         if prop is None: prop = ClassGroupProperties()
+         return ClassGroup.__eq__(self, other) \
-         assert(isinstance(prop, ClassGroupProperties))
+             and isinstance(other, ClassGroupRange) \
-         self.prop = prop
+             and self.__range == other.__range
+     def __repr__(self):
+         return "(" + str(self.__range) + ClassGroup.__repr__(self) + ")"
  class ClassGroupMap(ClassGroup):
      """Currently, this class is not used."""
-Line 631 
 class ClassGroupMap(ClassGroup):
+Line 770 
 class ClassGroupMap(ClassGroup):
      def GetPropertiesFromValue(self, value):
          pass
+     def GetDisplayText(self):
+         return "Map: " + self.map_type
      #
      # built-in mappings
      #

 Legend:



Removed from v.462
 


changed lines


 
Added in v.2657
 Legend:



Removed from v.462
 


changed lines


 
Added in v.2657
-Removed from v.462
+Added in v.2657

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26