Thuban/Model/classification.py

# Copyright (c) 2001, 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

__version__ = "$Revision$"

"""
A Classification provides a mapping from an input value
to data. This mapping can be specified in two ways. 
First, specific values can be associated with data. 
Second, ranges can be associated with data such that if 
an input value falls with a range that data is returned. 
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 
on the mapping algorithm.
"""
  
# fix for people using python2.1
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

# constants
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):
        """Initialize a classification.

           layer -- the Layer object who owns this classification

           field -- the name of the data table field that 
                    is to be used to classify layer properties
        """
 
        self.layer = None
        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) 

    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.
         
           If there is no layer then the field type is set to None, 
           otherwise the layer is queried to find the type of the
           field data

           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 GetField(self):
        """Return the name of the field."""
        return self.field

    def GetFieldType(self):
        """Return the field type."""
        return self.fieldType

    def SetFieldType(self, type):
        self.fieldType = type

    def SetLayer(self, layer):
        """Set the owning Layer of this classification."""

        if __debug__:
            if layer is not None:
                assert(isinstance(layer, Thuban.Model.layer.Layer))

        # prevent infinite recursion when calling SetClassification()
        if self.layer is not None and layer == self.layer:
            return

        self.layer = layer
        self.SetField(self.GetField()) # XXX: this sync's the fieldType

        if self.layer is not None:
            self.layer.SetClassification(self)

        #self.__SendMessage(LAYER_LEGEND_CHANGED)

    def GetLayer(self):
        """Return the parent layer."""
        return self.layer

    def SetDefaultGroup(self, group):
        """Set the group to be used when a value can't be classified.

           group -- group that the value maps to.
        """

        assert(isinstance(group, ClassGroupDefault))
        self.AddGroup(group)

    def GetDefaultGroup(self):
        """Return the default group."""
        return self.groups[0]

    #
    # these SetDefault* methods are really only provided for 
    # some backward compatibility. they should be considered
    # for removal once all the classification code is finished.
    #

    def SetDefaultFill(self, fill):
        """Set the default fill color.

        fill -- a Color object.
        """
        assert(isinstance(fill, Color))
        self.GetDefaultGroup().GetProperties().SetFill(fill)
        self.__SendMessage(LAYER_LEGEND_CHANGED)
        
    def GetDefaultFill(self):
        """Return the default fill color."""
        return self.GetDefaultGroup().GetProperties().GetFill()
        
    def SetDefaultLineColor(self, color):
        """Set the default line color.

        color -- a Color object.
        """
        assert(isinstance(color, Color))
        self.GetDefaultGroup().GetProperties().SetLineColor(color)
        self.__SendMessage(LAYER_LEGEND_CHANGED)
        
    def GetDefaultLineColor(self):
        """Return the default line color."""
        return self.GetDefaultGroup().GetProperties().GetLineColor()
        
    def SetDefaultLineWidth(self, lineWidth):
        """Set the default line width.

        lineWidth -- an integer > 0.
        """
        assert(isinstance(lineWidth, IntType))
        self.GetDefaultGroup().GetProperties().SetLineWidth(lineWidth)
        self.__SendMessage(LAYER_LEGEND_CHANGED)
        
    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
        """

        assert(isinstance(item, ClassGroup))

        if len(self.groups) > 0 and isinstance(item, ClassGroupDefault):
            self.groups[0] = item
            #self.SetDefaultGroup(item)
        else:
            self.groups.append(item)

        self.__SendMessage(LAYER_LEGEND_CHANGED)

    def GetGroup(self, value):
        """Return the associated group, or the default group.

           Groups are checked in the order the were added to the
           Classification.

           value -- the value to classify. If there is no mapping,
                    the field is None or value is None, 
                    return the default properties 
        """

        if self.GetField() is not None and value is not None:

            for i in range(1, len(self.groups)):
                group = self.groups[i]
                if group.Matches(value):
                    return group

        return self.GetDefaultGroup()

    def GetProperties(self, value):
        """Return the properties associated with the given value."""

        group = self.GetGroup(value)
        if isinstance(group, ClassGroupMap):
            return group.GetPropertiesFromValue(value)
        else:
            return group.GetProperties()

    def TreeInfo(self):
        items = []

        def build_color_item(text, color):
            if color is Color.None:
                return ("%s: %s" % (text, _("None")), None)

            return ("%s: (%.3f, %.3f, %.3f)" % 
                    (text, color.red, color.green, color.blue),
                    color)

        def build_item(group, string):
            label = group.GetLabel()
            if label == "":
                label = string
            else:
                label += " (%s)" % string

            props = group.GetProperties()
            i = []
            v = props.GetLineColor()
            i.append(build_color_item(_("Line Color"), v))
            v = props.GetLineWidth()
            i.append(_("Line Width: %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(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.

    The items are returned in the following order:
        default data, singletons, ranges, maps
    """

    def __init__(self, data): #default, points, ranges, maps):
        """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_index = 0
        #self.data_iter = iter(self.data)
        #self.iter = None

    def __iter__(self):
        return self

    def next(self):
        """Return the next item."""

        if self.data_index >= len(self.data):
            raise StopIteration
        else:
            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."""

    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 such that: line color = Color.Black, line width = 1,
                 and fill color = Color.None
        """

        self.stroke = None
        self.strokeWidth = 0
        self.fill = None

        if props is not None:
            self.SetProperties(props)
        else:
            self.SetLineColor(Color.None)
            self.SetLineWidth(1)
            self.SetFill(Color.None)

    def SetProperties(self, props):
        """Set this class's properties to those in class props."""

        assert(isinstance(props, ClassGroupProperties))
        self.SetLineColor(props.GetLineColor())
        self.SetLineWidth(props.GetLineWidth())
        self.SetFill(props.GetFill())
        
    def GetLineColor(self):
        """Return the line color as a Color object."""
        return self.stroke

    def SetLineColor(self, color):
        """Set the line color.

        color -- the color of the line. This must be a Color object.
        """

        assert(isinstance(color, Color))
        self.stroke = color

    def GetLineWidth(self):
        """Return the line width."""
        return self.strokeWidth

    def SetLineWidth(self, lineWidth):
        """Set the line width.

        lineWidth -- the new line width. This must be > 0.
        """
        assert(isinstance(lineWidth, IntType))
        if (lineWidth < 1):
            raise ValueError(_("lineWidth < 1"))

        self.strokeWidth = lineWidth

    def GetFill(self):
        """Return the fill color as a Color object."""
        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

    def __eq__(self, other):
        """Return true if 'props' has the same attributes as this class"""

        return isinstance(other, ClassGroupProperties)   \
            and self.stroke      == other.GetLineColor() \
            and self.strokeWidth == other.GetLineWidth() \
            and self.fill        == other.GetFill()

    def __ne__(self, other): 
        return not self.__eq__(other)

class ClassGroup:
    """A base class for all Groups within a Classification"""

    def __init__(self, label = ""):
        """Constructor.

        label -- A string representing the Group's label
        """

        self.label = None

        self.SetLabel(label)

    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))
        self.label = label

    def Matches(self, value):
        """Determines if this Group is associated with the given value.

        Returns False. This needs to be overridden by all subclasses.
        """
        return False

    def GetProperties(self):
        """Return the properties associated with the given value.

        Returns None. This needs to be overridden by all subclasses.
        """
        return None
 
    
class ClassGroupSingleton(ClassGroup):
    """A Group that is associated with a single value."""

    def __init__(self, value = 0, prop = None, label = ""):
        """Constructor.

        value -- the associated value.

        prop -- a ClassGroupProperites object. If prop is None a default
                 set of properties is created.

        label -- a label for this group.
        """
        ClassGroup.__init__(self, label)

        self.prop = None
        self.value = None

        self.SetValue(value)
        self.SetProperties(prop)

    def __copy__(self):
        return ClassGroupSingleton(self.GetValue(), 
                                   self.GetProperties(), 
                                   self.GetLabel())

    def GetValue(self):
        """Return the associated value."""
        return self.value

    def SetValue(self, value):
        """Associate this Group with the given 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

    def GetProperties(self):
        """Return the Properties associated with this Group."""

        return self.prop

    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 __eq__(self, other):
        return isinstance(other, ClassGroupSingleton) \
            and self.GetProperties() == other.GetProperties() \
            and self.GetValue() == other.GetValue()

    def __ne__(self, other):
        return not self.__eq__(other)

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 = ""):
        """Constructor.

        prop -- a ClassGroupProperites object. If prop is None a default
                 set of properties is created.

        label -- a label for this group.
        """

        ClassGroup.__init__(self, label)
        self.SetProperties(prop)

    def __copy__(self):
        return ClassGroupDefault(self.GetProperties(), self.GetLabel())

    def Matches(self, value):
        return True

    def GetProperties(self):
        """Return the Properties associated with this Group."""
        return self.prop

    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 __eq__(self, other):
        return isinstance(other, ClassGroupDefault) \
            and self.GetProperties() == other.GetProperties()

    def __ne__(self, other):
        return not self.__eq__(other)

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 = ""):
        """Constructor.

        The minumum value must be strictly less than the maximum.

        min -- the minimum range value

        max -- the maximum range value

        prop -- a ClassGroupProperites object. If prop is None a default
                 set of properties is created.

        label -- a label for this group.
        """

        ClassGroup.__init__(self, label)

        self.min = self.max = 0
        self.prop = None

        self.SetRange(min, max)
        self.SetProperties(prop)

    def __copy__(self):
        return ClassGroupRange(self.GetMin(), 
                               self.GetMax(), 
                               self.GetProperties(), 
                               self.GetLabel())

    def GetMin(self):
        """Return the range's minimum value."""
        return self.min

    def SetMin(self, min):
        """Set the range's minimum value.
     
        min -- the new minimum. Note that this must be less than the current
               maximum value. Use SetRange() to change both min and max values.
        """
     
        self.SetRange(min, self.max)

    def GetMax(self):
        """Return the range's maximum value."""
        return self.max

    def SetMax(self, max):
        """Set the range's maximum value.
     
        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)

    def SetRange(self, min, max):
        """Set a new range.

        Note that min must be strictly less than max.

        min -- the new minimum value
        min -- the new maximum value
        """

        if min >= max:
            raise ValueError(_("ClassGroupRange: %i(min) >= %i(max)!") %
                             (min, max))
        self.min = min
        self.max = max

    def GetRange(self):
        """Return the range as a tuple (min, max)"""
        return (self.min, self.max)

    def Matches(self, value):
        """Determine if the given value lies with the current range.

        The following check is used: min <= value < max.
        """

        return self.min <= value < self.max

    def GetProperties(self):
        """Return the Properties associated with this Group."""
        return self.prop

    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 __eq__(self, other):
        return isinstance(other, ClassGroupRange) \
            and self.GetProperties() == other.GetProperties() \
            and self.GetRange() == other.GetRange()

    def __ne__(self, other):
        return not self.__eq__(other)

class ClassGroupMap(ClassGroup):
    """Currently, this class is not used."""

    FUNC_ID = "id"

    def __init__(self, map_type = FUNC_ID, func = None, prop = None, label=""):
        ClassGroup.__init__(self, label)

        self.map_type = map_type
        self.func = func

        if self.func is None:
            self.func = func_id

    def Map(self, value):
        return self.func(value)

    def GetProperties(self):
        return None

    def GetPropertiesFromValue(self, value):
        pass

    #
    # built-in mappings
    #
    def func_id(value):
        return value

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