Thuban/UI/classgen.py

# Copyright (c) 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.

from Thuban import _

from wxPython.wx import *

from Thuban.Model.classification import Classification, ClassGroupRange, \
    ClassGroupSingleton, ClassGroupProperties

from Thuban.Model.table import Table, FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
     FIELDTYPE_STRING

from Thuban.Model.color import Color

import classifier

from Thuban.common import Str2Num

ID_CLASSGEN_GEN = 4001
ID_CLASSGEN_CLOSE = 4002
ID_CLASSGEN_COMBO = 4007

COMBOSTR_UNIFORM = _("Uniform Distribution")
COMBOSTR_UNIQUE = _("Unique Values")

class ClassGenDialog(wxDialog):
                                                                                
    def __init__(self, parent, layer, fieldName):
        """Inialize the class generating dialog.

        parent -- this must be an instance of the Classifier class
        """

        wxDialog.__init__(self, parent, -1, _("Generate Classification"),
                          style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
                                                                                
        self.parent = parent
        self.clazz = None

        self.type, name, width, prec = layer.table.field_info_by_name(fieldName)

        #############
        # we need to create genButton first because when we create the
        # panels they will call AllowGenerate() which uses genButton.
        #
        buttonSizer = wxBoxSizer(wxHORIZONTAL)
        self.genButton = wxButton(self, ID_CLASSGEN_GEN, _("Generate")) 

        buttonSizer.Add(self.genButton, 0, wxALL, 4)
        buttonSizer.Add(60, 20, 0, wxALL, 4)
        buttonSizer.Add(wxButton(self, ID_CLASSGEN_CLOSE, _("Close")), 
                        0, wxALL, 4)

        #############

        sizer = wxBoxSizer(wxVERTICAL)

        sizer.Add(wxStaticText(self, -1, _("Field: %s") % fieldName), 
                  0, wxALL, 4)
        sizer.Add(wxStaticText(
            self, -1, 
            _("Field Type: %s") % classifier.Classifier.type2string[self.type]),
            0, wxALL, 4)

        psizer = wxBoxSizer(wxHORIZONTAL)
        psizer.Add(wxStaticText(
            self, -1, 
            _("Generate:")),
            0, wxALIGN_CENTER_VERTICAL, 0)

        self.genCombo = wxComboBox(self, 
                                ID_CLASSGEN_COMBO, 
                                "", style = wxCB_READONLY)
        psizer.Add(self.genCombo, 1, wxALL | wxGROW, 4)
        EVT_COMBOBOX(self, ID_CLASSGEN_COMBO, self._OnGenTypeSelect)

        sizer.Add(psizer, 0, wxALL | wxGROW, 4)

        #############

        self.genPanel = None

        panel = GenUniquePanel(self, layer, fieldName, self.type)
        self.genCombo.Append(COMBOSTR_UNIQUE)
        self.genCombo.SetClientData(self.genCombo.GetCount() - 1, panel)
        sizer.Add(panel, 1, wxGROW | wxALL, 4)

        self.genPanel = panel

        if self.type in (FIELDTYPE_INT, FIELDTYPE_DOUBLE):
            panel = GenUniformPanel(self, layer, fieldName, self.type)
            self.genCombo.Append(COMBOSTR_UNIFORM)
            self.genCombo.SetClientData(self.genCombo.GetCount() - 1, panel)
            sizer.Add(panel, 0, wxGROW | wxALL, 4)
            sizer.Show(panel, False)

        #############

        self.propPanel = None

        panel = CustomRampPanel(self, layer.ShapeType())

        self.propPanel = panel

        sizer.Add(panel, 1, wxALL | wxGROW, 4)

        #############

        sizer.Add(buttonSizer, 0, 
                  wxALL | wxALIGN_BOTTOM | wxALIGN_CENTER_HORIZONTAL, 4)


        self.SetSizer(sizer)
        self.SetAutoLayout(True)
        sizer.SetSizeHints(self)

        self.sizer = sizer

        EVT_BUTTON(self, ID_CLASSGEN_GEN, self._OnGenerate)
        EVT_BUTTON(self, ID_CLASSGEN_CLOSE, self._OnCloseBtn)

    def GetClassification(self):
        return self.clazz

    def AllowGenerate(self, on):
        pass #self.genButton.Enable(on)

    def _OnGenerate(self, event):

        selIndex = self.genCombo.GetSelection()

        sel = self.genCombo.GetString(selIndex)
        genPanel = self.genCombo.GetClientData(selIndex)
        propPanel = self.propPanel

        if sel == COMBOSTR_UNIFORM:

            min = genPanel.GetMin()
            max = genPanel.GetMax()
            numGroups = genPanel.GetNumGroups()
            sp = propPanel.GetStartProperties()
            ep = propPanel.GetEndProperties()

            if min is not None \
                and max is not None \
                and numGroups is not None:

                self.clazz = ClassGenerator().GenUnifromDistribution(
                             min, max, numGroups, sp, ep,
                             self.type == FIELDTYPE_INT)

                self.parent._SetClassification(self.clazz)

        elif sel == COMBOSTR_UNIQUE:

            list = genPanel.GetValueList()
            numGroups = genPanel.GetNumGroups()
            sp = propPanel.GetStartProperties()
            ep = propPanel.GetEndProperties()

            if len(list) > 0 \
                and numGroups is not None:

                self.clazz = ClassGenerator().GenSingletonsFromList(
                                list, numGroups, sp, ep)

                self.parent._SetClassification(self.clazz)

        else:
            pass

    def _OnCloseBtn(self, event):
        self.Close()

    def _OnGenTypeSelect(self, event):

        combo = event.GetEventObject()

        selIndex = combo.GetSelection()

        if self.genPanel is not None:
            self.sizer.Show(self.genPanel, False)

        self.genPanel = combo.GetClientData(selIndex)
        if self.genPanel is not None:
            self.sizer.Show(self.genPanel, True)

        self.sizer.SetSizeHints(self)
        self.sizer.Layout()


ID_UNIFORM_MIN = 4001
ID_UNIFORM_MAX = 4002
ID_UNIFORM_NGROUPS = 4003
ID_UNIFORM_STEP = 4004
ID_UNIFORM_RETRIEVE = 4005

class GenUniformPanel(wxPanel):

    def __init__(self, parent, layer, fieldName, fieldType):
        wxPanel.__init__(self, parent, -1)

        self.parent = parent
        self.layer = layer
        self.fieldName = fieldName
        self.fieldType = fieldType

        topSizer = wxStaticBoxSizer(wxStaticBox(self, -1, ""), 
                                    wxVERTICAL)

        #############

        sizer = wxBoxSizer(wxHORIZONTAL)

        sizer.Add(wxStaticText(self, -1, _("Min:")), 0, wxALL, 4) 
        self.minCtrl = wxTextCtrl(self, ID_UNIFORM_MIN, style=wxTE_RIGHT)
        sizer.Add(self.minCtrl, 1, wxALL, 4)
        EVT_TEXT(self, ID_UNIFORM_MIN, self._OnRangeChanged)

        sizer.Add(wxStaticText(self, -1, _("Max:")), 0, wxALL, 4) 
        self.maxCtrl = wxTextCtrl(self, ID_UNIFORM_MAX, style=wxTE_RIGHT)
        sizer.Add(self.maxCtrl, 1, wxALL, 4)
        EVT_TEXT(self, ID_UNIFORM_MAX, self._OnRangeChanged)

        sizer.Add(wxButton(self, ID_UNIFORM_RETRIEVE, _("Retrieve From Table")),
            0, wxALL, 4)
        EVT_BUTTON(self, ID_UNIFORM_RETRIEVE, self._OnRetrieve)

        topSizer.Add(sizer, 1, wxGROW, 0)

        #############

        sizer = wxBoxSizer(wxHORIZONTAL)

        sizer.Add(wxStaticText(self, -1, _("Number of Groups:")), 0, wxALL, 4)
        self.numGroupsCtrl = wxSpinCtrl(self, ID_UNIFORM_NGROUPS, style=wxTE_RIGHT)
        EVT_TEXT(self, ID_UNIFORM_NGROUPS, self._OnNumGroupsChanged)
        EVT_SPINCTRL(self, ID_UNIFORM_NGROUPS, self._OnNumGroupsChanged)
        sizer.Add(self.numGroupsCtrl, 1, wxALL, 4)

        sizer.Add(wxStaticText(self, -1, _("Stepping:")), 0, wxALL, 4)
        self.stepCtrl = wxTextCtrl(self, ID_UNIFORM_STEP, style=wxTE_RIGHT)
        EVT_TEXT(self, ID_UNIFORM_STEP, self._OnSteppingChanged)
        sizer.Add(self.stepCtrl , 1, wxALL, 4)

        topSizer.Add(sizer, 1, wxGROW, 0)

        #############

        self.SetSizer(topSizer)
        self.SetAutoLayout(True)
        topSizer.SetSizeHints(self)

        self.numGroupsChanging = False
        self.steppingChanging = False

        self.numGroupsCtrl.SetRange(1, 100)

        self.numGroupsCtrl.SetValue(1)
        self.stepCtrl.SetValue("1")
        self.maxCtrl.SetValue("0")
        self.minCtrl.SetValue("0")
        self.minCtrl.SetFocus()

    def GetNumGroups(self):
        value = self.numGroupsCtrl.GetValue()
        return self.__GetValidatedTypeEntry(self.numGroupsCtrl, 
                                            value,
                                            FIELDTYPE_INT,
                                            None)

    def GetStepping(self):
        step = self.stepCtrl.GetValue()
        return self.__GetValidatedTypeEntry(self.stepCtrl, 
                                            step,
                                            self.fieldType,
                                            0)

    def GetMin(self):
        min = self.minCtrl.GetValue()
        max = self.maxCtrl.GetValue()
        return self.__GetValidatedTypeEntry(self.minCtrl, 
                                            min,
                                            self.fieldType,
                                            max)

    def GetMax(self):
        min = self.minCtrl.GetValue()
        max = self.maxCtrl.GetValue()
        return self.__GetValidatedTypeEntry(self.maxCtrl, 
                                            max,
                                            self.fieldType,
                                            min)

    def _OnRangeChanged(self, event):

        hasFocus = wxWindow_FindFocus() == event.GetEventObject()
        min = self.GetMin()
        max = self.GetMax()

        on = min is not None \
            and max is not None

        self.numGroupsCtrl.Enable(on)
        self.stepCtrl.Enable(on)

        if on:
            self.numGroupsCtrl.SetRange(1, abs(max - min) / 0.001)

        ngroups = self.GetNumGroups()

        if ngroups is not None  \
            and min is not None \
            and max is not None \
            and ngroups != 0:

            #self.stepCtrl.SetValue(str((max - min) / ngroups))
            self.stepCtrl.SetValue(str(self.__CalcStepping(min, max, ngroups)))
            #self.numGroupsCtrl.SetValue(ngroups)

            self.parent.AllowGenerate(self.GetStepping() is not None)
        else:
            self.parent.AllowGenerate(False)


        if hasFocus:
            event.GetEventObject().SetFocus()

    def _OnNumGroupsChanged(self, event):
        if self.steppingChanging:
            self.steppingChanging = False
            return


        obj = event.GetEventObject()
        ngroups = self.GetNumGroups()
        min = self.GetMin()
        max = self.GetMax()

        if ngroups >= self.numGroupsCtrl.GetMax():
            self.numGroupsCtrl.SetRange(1, ngroups + 1)

        if ngroups is not None  \
            and min is not None \
            and max is not None \
            and ngroups != 0:

            #
            # changing the value in the stepCtrl sends an event
            # that the control is changing, at which point
            # we try to update the numGroupsCtrl. This causes
            # an infinite recursion. This flag and the one
            # called steppingChanging tries to prevent the recursion.
            #
            self.numGroupsChanging = True

            self.stepCtrl.SetValue(str(self.__CalcStepping(min, max, ngroups)))

            self.parent.AllowGenerate(self.GetStepping() is not None)
        else:
            self.parent.AllowGenerate(False)


    def _OnSteppingChanged(self, event):
        if self.numGroupsChanging:
            self.numGroupsChanging = False
            return

        step = self.GetStepping()
        min = self.GetMin()
        max = self.GetMax()

        if step is not None  \
            and min is not None \
            and max is not None \
            and step != 0:

            #
            # see note in _OnNumGroupsChanged
            #
            self.steppingChanging = True
            self.numGroupsCtrl.SetValue(self.__CalcNumGroups(min, max, step))

            self.parent.AllowGenerate(self.GetNumGroups() is not None)
        else:
            self.parent.AllowGenerate(False)

    def _OnRetrieve(self, event):

        if self.layer.table is not None:
            range = self.layer.table.field_range(self.fieldName)
            self.minCtrl.SetValue(str(range[0][0]))
            self.maxCtrl.SetValue(str(range[1][0]))

    def __GetValidatedTypeEntry(self, win, value, type, badValue = None):

        if type == FIELDTYPE_INT: 
            func = int
        elif type == FIELDTYPE_DOUBLE:
            func = float
        elif type == FIELDTYPE_STRING:
            func = str
        else:
            assert False, "Unsupported FIELDTYPE"
            pass

        if self.__ValidateEntry(win, value, func, badValue):
            return func(value)

        return None

    def __ValidateEntry(self, win, value, test, badValue = None):

        valid = value != ""

        try:
            if valid:
                value = test(value)

                if badValue is not None:
                    valid = value != test(badValue)
        except ValueError:
            valid = False

        if valid:
            win.SetForegroundColour(wxBLACK)
        else:
            win.SetForegroundColour(wxRED)

        win.Refresh()

        return valid

    def __CalcStepping(self, min, max, ngroups):
        step = Str2Num(str((max - min) / float(ngroups)))
        if self.fieldType == FIELDTYPE_INT:
            step = int(step)

        return step

    def __CalcNumGroups(self, min, max, step):
        n = int((max - min) / step)
        if n == 0:
            n = 1

        if self.fieldType == FIELDTYPE_INT and step == 1:
            n += 1

        return n


ID_UNIQUE_RETRIEVE = 4001
ID_UNIQUE_USEALL = 4002
ID_UNIQUE_USE = 4003
ID_UNIQUE_DONTUSE = 4004
ID_UNIQUE_USENONE = 4005
ID_UNIQUE_SORTAVAIL = 4006
ID_UNIQUE_SORTUSE = 4007

class GenUniquePanel(wxPanel):

    def __init__(self, parent, layer, fieldName, fieldType):
        wxPanel.__init__(self, parent, -1)

        self.parent = parent
        self.layer = layer
        self.fieldName = fieldName
        self.fieldType = fieldType

        topSizer = wxStaticBoxSizer(wxStaticBox(self, -1, ""), 
                                    wxVERTICAL)


        sizer = wxBoxSizer(wxHORIZONTAL)

        self.dataList = []

        psizer = wxBoxSizer(wxVERTICAL)
        self.list_avail = wxListCtrl(self, -1, 
                        style=wxLC_REPORT | wxLC_SINGLE_SEL)
        self.list_avail.InsertColumn(0, "Available")
        self.list_avail_data = []
        psizer.Add(self.list_avail, 1, wxGROW, 0)

        psizer.Add(wxButton(self, ID_UNIQUE_SORTAVAIL, _("Sort")))

        EVT_BUTTON(self, ID_UNIQUE_SORTAVAIL, self._OnSortAvailList)

        sizer.Add(psizer, 1, wxGROW, 0)

        
        bsizer = wxBoxSizer(wxVERTICAL)
        bsizer.Add(wxButton(self, ID_UNIQUE_USEALL, _("Use All")), 
                   0, wxGROW | wxALL, 4)
        bsizer.Add(wxButton(self, ID_UNIQUE_USE, _("Use >>")), 
                   0, wxGROW | wxALL, 4)
        bsizer.Add(wxButton(self, ID_UNIQUE_DONTUSE, _("<< Don't Use")), 
                   0, wxGROW | wxALL, 4)
        bsizer.Add(wxButton(self, ID_UNIQUE_USENONE, _("Use None")), 
                   0, wxGROW | wxALL, 4)

        EVT_BUTTON(self, ID_UNIQUE_USEALL, self._OnUseAll)
        EVT_BUTTON(self, ID_UNIQUE_USE, self._OnUse)
        EVT_BUTTON(self, ID_UNIQUE_DONTUSE, self._OnDontUse)
        EVT_BUTTON(self, ID_UNIQUE_USENONE, self._OnUseNone)

        sizer.Add(bsizer, 0, wxALL | wxALIGN_CENTER_VERTICAL, 4)

        psizer = wxBoxSizer(wxVERTICAL)
        self.list_use = wxListCtrl(self, -1, 
                        style=wxLC_REPORT | wxLC_SINGLE_SEL)
        self.list_use.InsertColumn(0, "Use")
        self.list_use_data = []
        psizer.Add(self.list_use, 1, wxGROW, 0)

        psizer.Add(wxButton(self, ID_UNIQUE_SORTUSE, _("Sort")))

        EVT_BUTTON(self, ID_UNIQUE_SORTUSE, self._OnSortUseList)

        sizer.Add(psizer, 1, wxGROW, 0)

        bsizer = wxBoxSizer(wxVERTICAL)
        bsizer.Add(wxButton(self, ID_UNIQUE_RETRIEVE, 
                            _("Retrieve From Table")), 
                   0, wxGROW | wxALL, 4)

        EVT_BUTTON(self, ID_UNIQUE_RETRIEVE, self._OnRetrieve)

        sizer.Add(bsizer, 0, wxALL, 4)

        topSizer.Add(sizer, 1, wxGROW, 0)

        self.SetSizer(topSizer)
        self.SetAutoLayout(True)
        topSizer.SetSizeHints(self)

        self.parent.AllowGenerate(False)

        self.mylist = ["Hallo", "Welt!", "Wie", "geht", "es", "dir", "?"]

    def GetNumGroups(self):
        return self.list_use.GetItemCount()

    def GetValueList(self):
        list = []
        for i in range(self.list_use.GetItemCount()):
            list.append(self.dataList[self.list_use.GetItemData(i)])
        return list

    def _OnSortAvailList(self, event):
        self.list_avail.SortItems(lambda i1, i2:
                                    cmp(self.dataList[i1],
                                        self.dataList[i2]))

    def _OnSortUseList(self, event):
        self.list_use.SortItems(lambda i1, i2:
                                    cmp(self.dataList[i1],
                                        self.dataList[i2]))

    def _OnRetrieve(self, event):
        self.list_use.DeleteAllItems()
        self.list_use_data = []
        self.list_avail.DeleteAllItems()
        self.list_avail_data = []

        list = self.layer.table.GetUniqueValues(self.fieldName)
        index = 0
        for v in list:
            self.dataList.append(v)
            i = self.list_avail.InsertStringItem(index, str(v))
            self.list_avail.SetItemData(index, i)

            self.list_avail_data.append(v)
            index += 1

    def _OnUseAll(self, event):
        for i in range(self.list_avail.GetItemCount()):
            self.__MoveListItem(0, self.list_avail, self.list_use)

    def _OnUse(self, event):
        print "_OnUse"
        self.__MoveSelectedItems(self.list_avail, self.list_use)

    def _OnDontUse(self, event):
        print "_OnDontUse"
        self.__MoveSelectedItems(self.list_use, self.list_avail)

    def _OnUseNone(self, event):
        print "_OnUseNone"

        for i in range(self.list_use.GetItemCount()):
            self.__MoveListItem(0, self.list_use, self.list_avail)

    def __MoveSelectedItems(self, list_src, list_dest):
        while True:
            index = list_src.GetNextItem(-1,
                                         wxLIST_NEXT_ALL, 
                                         wxLIST_STATE_SELECTED)

            if index == -1:
                break

            self.__MoveListItem(index, list_src, list_dest)


    def __MoveListItem(self, index, list_src, list_dest):

        item = list_src.GetItem(index)

        x = list_dest.InsertStringItem(
                list_dest.GetItemCount(), 
                str(self.dataList[item.GetData()]))

        list_dest.SetItemData(x, item.GetData())

        list_src.DeleteItem(index)

#   def _OnListSize(self, event):
#       list = event.GetEventObject()

#       list.SetColumnWidth(0, event.GetSize().GetWidth())
#       

ID_CUSTOMRAMP_COPYSTART = 4001
ID_CUSTOMRAMP_COPYEND = 4002
ID_CUSTOMRAMP_EDITSTART = 4003
ID_CUSTOMRAMP_EDITEND = 4004
ID_CUSTOMRAMP_SPROP = 4005
ID_CUSTOMRAMP_EPROP = 4006

class CustomRampPanel(wxPanel):

    def __init__(self, parent, shapeType):
        wxPanel.__init__(self, parent, -1)

        topSizer = wxStaticBoxSizer(wxStaticBox(self, -1, ""), wxHORIZONTAL)

        bsizer = wxBoxSizer(wxVERTICAL)
        bsizer.Add(wxStaticText(self, -1, _("Start:")), 0, wxALL | wxCENTER, 4)
        self.startPropCtrl = classifier.ClassGroupPropertiesCtrl(
            self, ID_CUSTOMRAMP_SPROP, 
            ClassGroupProperties(), shapeType,
            style=wxSIMPLE_BORDER, size=(40, 20))
        bsizer.Add(self.startPropCtrl, 1, wxGROW | wxALL | wxCENTER, 4)
        bsizer.Add(wxButton(self, ID_CUSTOMRAMP_EDITSTART, _("Change")),
                   0, wxGROW | wxALL | wxCENTER, 4)

        topSizer.Add(bsizer,
                   1, wxALL \
                      | wxSHAPED \
                      | wxALIGN_CENTER_HORIZONTAL \
                      | wxALIGN_CENTER_VERTICAL, \
                   4)

        bsizer = wxBoxSizer(wxVERTICAL)
        bsizer.Add(wxButton(self, ID_CUSTOMRAMP_COPYSTART, _("Copy >>")),
                   0, wxGROW | wxALL, 4)
        bsizer.Add(wxButton(self, ID_CUSTOMRAMP_COPYEND, _("<< Copy")),
                   0, wxGROW | wxALL, 4)

        topSizer.Add(bsizer,
                   0, wxALL \
                      | wxALIGN_CENTER_HORIZONTAL \
                      | wxALIGN_CENTER_VERTICAL, 
                   4)

        bsizer = wxBoxSizer(wxVERTICAL)
        bsizer.Add(wxStaticText(self, -1, _("End:")), 0, wxALL | wxCENTER, 4)
        self.endPropCtrl = classifier.ClassGroupPropertiesCtrl(
            self, ID_CUSTOMRAMP_EPROP, 
            ClassGroupProperties(), shapeType,
            style=wxSIMPLE_BORDER, size=(40, 20))
        bsizer.Add(self.endPropCtrl, 1, wxGROW | wxALL | wxCENTER, 4)
        bsizer.Add(wxButton(self, ID_CUSTOMRAMP_EDITEND, _("Change")),
                   0, wxGROW | wxALL | wxCENTER, 4)

        topSizer.Add(bsizer,
                   1, wxALL \
                      | wxSHAPED \
                      | wxALIGN_RIGHT \
                      | wxALIGN_CENTER_HORIZONTAL \
                      | wxALIGN_CENTER_VERTICAL, 
                   4)

        EVT_BUTTON(self, ID_CUSTOMRAMP_COPYSTART, self._OnCopyStart)
        EVT_BUTTON(self, ID_CUSTOMRAMP_COPYEND, self._OnCopyEnd)
        EVT_BUTTON(self, ID_CUSTOMRAMP_EDITSTART, self._OnEditStart)
        EVT_BUTTON(self, ID_CUSTOMRAMP_EDITEND, self._OnEditEnd)

        self.SetSizer(topSizer)
        self.SetAutoLayout(True)
        topSizer.SetSizeHints(self)

    def GetStartProperties(self):
        return self.startPropCtrl.GetProperties()

    def GetEndProperties(self):
        return self.endPropCtrl.GetProperties()

    def _OnCopyStart(self, event):
        self.endPropCtrl.SetProperties(self.startPropCtrl.GetProperties())

    def _OnCopyEnd(self, event):
        self.startPropCtrl.SetProperties(self.endPropCtrl.GetProperties())

    def _OnEditStart(self, event):
        self.startPropCtrl.DoEdit()

    def _OnEditEnd(self, event):
        self.endPropCtrl.DoEdit()

class ClassGenerator:

    def GenSingletonsFromList(self, list, numGroups, prop1, prop2):
        """Generate a new classification consisting solely of singletons.

        The resulting classification will consist of at most 'numGroups'
        groups whose group properties ramp between 'prop1' and 'prop2'. There
        could be fewer groups if 'list' contains fewer that 'numGroups' items.

        list -- any object that implements the iterator interface

        numGroups -- how many groups to generate. This can not be
                     determined while the classification is being
                     generated because the stepping values must
                     be precalculated to ramp between prop1 and prop2.

        prop1 -- initial group property values

        prop2 -- final group property values
        """

        clazz = Classification()
        if numGroups == 0: return clazz

        for value, prop in zip(list, CustomRamp(numGroups, prop1, prop2)):
            clazz.AppendGroup(ClassGroupSingleton(value, prop))

        return clazz

    def GenSingletons(self, min, max, numGroups, prop1, prop2):

        clazz = Classification()

        #step = int((max - min) / float(numGroups))
        step = int(Str2Num(str((max - min + 1) / float(numGroups))))

        if numGroups > 0:
            cur_value = min

            for prop in CustomRamp(numGroups, prop1, prop2):
                clazz.AppendGroup(
                    ClassGroupSingleton(
                        Str2Num(str(cur_value)), 
                        prop))
                cur_value += step

        return clazz

    def GenUnifromDistribution(self, min, max, numGroups, 
                               prop1, prop2, intStep = False):
        """Generate a classification with numGroups range groups
        each with the same interval.

        intStep -- force the calculated stepping to an integer.
                   Useful if the values are integers but the
                   number of groups specified doesn't evenly
                   divide (max - min).
        """

        clazz = Classification()
        if numGroups == 0: return clazz

        step = Str2Num(str((max - min) / float(numGroups)))

        if intStep:
            step = int(step)

        cur_min = min
        cur_max = cur_min + step

        i = 0
        for prop in CustomRamp(numGroups, prop1, prop2):

            if i == (numGroups - 1):
                cur_max = max

            # this check guards against rounding issues
            if cur_min != cur_max:
                clazz.AppendGroup(
                    ClassGroupRange(
                        Str2Num(str(cur_min)), 
                        Str2Num(str(cur_max)), 
                        prop))

            cur_min = cur_max
            cur_max += step
            i += 1

        return clazz

CLR  = 0
STEP = 1
class CustomRamp:

    def __init__(self, num, prop1, prop2):

        self.count = int(num)
        num = float(num)

        clr = prop1.GetLineColor()
        lineColor2 = prop2.GetLineColor()
        
        self.noLine = clr is not Color.Transparent \
                        and lineColor2 is not Color.Transparent


        self.lineInfo = self.__GetColorInfo(prop1.GetLineColor(), 
                                            prop2.GetLineColor(),
                                            num)

        self.fillInfo = self.__GetColorInfo(prop1.GetFill(), 
                                            prop2.GetFill(),
                                            num)

        self.lineWidth = prop1.GetLineWidth()
        self.lineWidthStep = (prop2.GetLineWidth() - self.lineWidth) / num

    def __iter__(self):
        return self

    def next(self):
        if self.count == 0:
            raise StopIteration

        prop = ClassGroupProperties()

        if self.lineInfo is None:
            prop.SetLineColor(Color.Transparent)
        else:
            prop.SetLineColor(Color(self.lineInfo[CLR][0] / 255,
                                    self.lineInfo[CLR][1] / 255, 
                                    self.lineInfo[CLR][2] / 255))

            self.lineInfo[CLR][0] += self.lineInfo[STEP][0]
            self.lineInfo[CLR][1] += self.lineInfo[STEP][1]
            self.lineInfo[CLR][2] += self.lineInfo[STEP][2]

        if self.fillInfo is None:
            prop.SetFill(Color.Transparent)
        else:
            prop.SetFill(Color(self.fillInfo[CLR][0] / 255, 
                            self.fillInfo[CLR][1] / 255, 
                            self.fillInfo[CLR][2] / 255))

            self.fillInfo[CLR][0] += self.fillInfo[STEP][0]
            self.fillInfo[CLR][1] += self.fillInfo[STEP][1]
            self.fillInfo[CLR][2] += self.fillInfo[STEP][2]


        prop.SetLineWidth(int(self.lineWidth))
        self.lineWidth        += self.lineWidthStep

        self.count -= 1

        return prop

    def __GetColorInfo(self, color1, color2, numGroups):

        if color1 is Color.Transparent and color2 is Color.Transparent:
            #
            # returning early
            #
            return None
        elif color1 is not Color.Transparent and color2 is Color.Transparent:
            color = [color1.red   * 255, 
                     color1.green * 255, 
                     color1.blue  * 255]
            step = (0, 0, 0)
        elif color1 is Color.Transparent and color2 is not Color.Transparent:
            color = [color2.red   * 255, 
                     color2.green * 255, 
                     color2.blue  * 255]
            step = (0, 0, 0)
        else:
            color = [color1.red   * 255, 
                     color1.green * 255, 
                     color1.blue  * 255]
            step = ((color2.red   * 255 - color1.red   * 255)   / numGroups,
                    (color2.green * 255 - color1.green * 255) / numGroups,
                    (color2.blue  * 255 - color1.blue  * 255)  / numGroups)


        return (color, step)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision