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.

import sys

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

import resource

from Thuban.common import Str2Num

ID_CLASSGEN_GEN = 4001
ID_CLASSGEN_CLOSE = 4002
ID_CLASSGEN_GENCOMBO = 4007
ID_CLASSGEN_PROPCOMBO = 4008

USEALL_BMP  = "group_use_all"
USE_BMP     = "group_use"
USENOT_BMP  = "group_use_not"
USENONE_BMP = "group_use_none"

GENCOMBOSTR_UNIFORM = _("Uniform Distribution")
GENCOMBOSTR_UNIQUE = _("Unique Values")

PROPCOMBOSTR_CUSTOM     = _("Custom Ramp")
PROPCOMBOSTR_GREY       = _("Grey Ramp")
PROPCOMBOSTR_RED        = _("Red Ramp")
PROPCOMBOSTR_GREEN      = _("Green Ramp")
PROPCOMBOSTR_BLUE       = _("Blue Ramp")
PROPCOMBOSTR_HOT2COLD   = _("Hot-to-Cold Ramp")

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, 
            _("Data 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 = wxChoice(self, ID_CLASSGEN_GENCOMBO)
        psizer.Add(self.genCombo, 1, wxALL | wxGROW, 4)
        EVT_CHOICE(self, ID_CLASSGEN_GENCOMBO, self._OnGenTypeSelect)

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

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

        self.genPanel = None

        panel = GenUniquePanel(self, layer, fieldName, self.type)
        self.genCombo.Append(GENCOMBOSTR_UNIQUE, 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(GENCOMBOSTR_UNIFORM, panel)
            sizer.Add(panel, 1, wxGROW | wxALL, 4)
            sizer.Show(panel, False)

        self.genCombo.SetSelection(0)

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

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

        self.propCombo = wxChoice(self, ID_CLASSGEN_PROPCOMBO)
        psizer.Add(self.propCombo, 1, wxALL | wxGROW, 4)
        EVT_CHOICE(self, ID_CLASSGEN_PROPCOMBO, self._OnPropTypeSelect)
        sizer.Add(psizer, 0, wxALL | wxGROW, 4)

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

        self.propPanel = None
        panel = CustomRampPanel(self, layer.ShapeType())
        sizer.Add(panel, 1, wxALL | wxGROW, 4)
        sizer.Show(panel, False)

        self.propCombo.Append(PROPCOMBOSTR_GREY,  GreyRamp())
        self.propCombo.Append(PROPCOMBOSTR_RED,   RedRamp())
        self.propCombo.Append(PROPCOMBOSTR_GREEN, GreenRamp())
        self.propCombo.Append(PROPCOMBOSTR_BLUE,  BlueRamp())
        self.propCombo.Append(PROPCOMBOSTR_HOT2COLD,  HotToColdRamp())
        self.propCombo.Append(PROPCOMBOSTR_CUSTOM, panel)

        self.propCombo.SetSelection(0)


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

        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):

        index = self.genCombo.GetSelection()

        genSel = self.genCombo.GetString(index)
        genPanel = self.genCombo.GetClientData(index)

        propPanel = self.propPanel

        if genSel in (GENCOMBOSTR_UNIFORM, GENCOMBOSTR_UNIQUE):
            numGroups = genPanel.GetNumGroups()

            index = self.propCombo.GetSelection()

            propSel = self.propCombo.GetString(index)
            propPanel = self.propCombo.GetClientData(index)

            ramp = propPanel.GetRamp()

            if genSel == GENCOMBOSTR_UNIFORM:

                min = genPanel.GetMin()
                max = genPanel.GetMax()

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

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

                    self.parent._SetClassification(self.clazz)

            elif genSel == GENCOMBOSTR_UNIQUE:

                list = genPanel.GetValueList()

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

                    self.clazz = ClassGenerator().GenSingletonsFromList(
                                    list, numGroups, ramp)

                    self.parent._SetClassification(self.clazz)

    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()

    def _OnPropTypeSelect(self, event):
        combo = event.GetEventObject()

        selIndex = combo.GetSelection()
        sel = combo.GetString(selIndex)

        if isinstance(self.propPanel, wxPanel):
            self.sizer.Show(self.propPanel, False)

        self.propPanel = combo.GetClientData(selIndex)

        if isinstance(self.propPanel, wxPanel):
            self.sizer.Show(self.propPanel, 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, sys.maxint)

        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)

        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 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
ID_UNIQUE_REVAVAIL = 4008
ID_UNIQUE_REVUSE = 4009

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)


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

        EVT_BUTTON(self, ID_UNIQUE_RETRIEVE, self._OnRetrieve)

        #topSizer.Add(bsizer, 0, wxALL, 4)

        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)

        bsizer = wxBoxSizer(wxHORIZONTAL)
        bsizer.Add(wxButton(self, ID_UNIQUE_SORTAVAIL, _("Sort")))
        EVT_BUTTON(self, ID_UNIQUE_SORTAVAIL, self._OnSortList)

        bsizer.Add(wxButton(self, ID_UNIQUE_REVAVAIL, _("Reverse")))
        EVT_BUTTON(self, ID_UNIQUE_REVAVAIL, self._OnReverseList)

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

        
        bsizer = wxBoxSizer(wxVERTICAL)

        bmp = resource.GetBitmapResource(USEALL_BMP, wxBITMAP_TYPE_XPM)
        bsizer.Add(wxBitmapButton(self, ID_UNIQUE_USEALL, bmp),
                   0, wxGROW | wxALL, 4)
        bmp = resource.GetBitmapResource(USE_BMP, wxBITMAP_TYPE_XPM)
        bsizer.Add(wxBitmapButton(self, ID_UNIQUE_USE, bmp), 
                   0, wxGROW | wxALL, 4)
        bmp = resource.GetBitmapResource(USENOT_BMP, wxBITMAP_TYPE_XPM)
        bsizer.Add(wxBitmapButton(self, ID_UNIQUE_DONTUSE, bmp), 
                   0, wxGROW | wxALL, 4)
        bmp = resource.GetBitmapResource(USENONE_BMP, wxBITMAP_TYPE_XPM)
        bsizer.Add(wxBitmapButton(self, ID_UNIQUE_USENONE, bmp), 
                   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)

        bsizer = wxBoxSizer(wxHORIZONTAL)
        bsizer.Add(wxButton(self, ID_UNIQUE_SORTUSE, _("Sort")))
        EVT_BUTTON(self, ID_UNIQUE_SORTUSE, self._OnSortList)

        bsizer.Add(wxButton(self, ID_UNIQUE_REVUSE, _("Reverse")))
        EVT_BUTTON(self, ID_UNIQUE_REVUSE, self._OnReverseList)

        psizer.Add(bsizer, 0, wxGROW, 0)

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


        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 _OnSortList(self, event):
        id = event.GetId()

        if id == ID_UNIQUE_SORTUSE:
            list = self.list_use
        else:
            list = self.list_avail

        list.SortItems(lambda i1, i2: cmp(self.dataList[i1], 
                                          self.dataList[i2]))

    def _OnReverseList(self, event):
        id = event.GetId()

        if id == ID_UNIQUE_REVUSE:
            list = self.list_use
        else:
            list = self.list_avail

        #
        # always returning 1 reverses the list
        #
        list.SortItems(lambda i1, i2: 1)

    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):
        self.__MoveSelectedItems(self.list_avail, self.list_use)

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

    def _OnUseNone(self, event):

        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)

        bmp = resource.GetBitmapResource(USE_BMP, wxBITMAP_TYPE_XPM)
        bsizer = wxBoxSizer(wxVERTICAL)
        bsizer.Add(wxBitmapButton(self, ID_CUSTOMRAMP_COPYSTART, bmp),
                   0, wxGROW | wxALL, 4)
        bmp = resource.GetBitmapResource(USENOT_BMP, wxBITMAP_TYPE_XPM)
        bsizer.Add(wxBitmapButton(self, ID_CUSTOMRAMP_COPYEND, bmp),
                   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 GetRamp(self):
        return CustomRamp(self.startPropCtrl.GetProperties(),
                          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, ramp):
        """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

        ramp.SetNumGroups(numGroups)

        for value, prop in zip(list, ramp):
            clazz.AppendGroup(ClassGroupSingleton(value, prop))

        return clazz

    def GenSingletons(self, min, max, numGroups, ramp):

        clazz = Classification()

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

        if numGroups > 0:
            cur_value = min

            ramp.SetNumGroups(numGroups)

            for prop in ramp:
                clazz.AppendGroup(
                    ClassGroupSingleton(
                        Str2Num(str(cur_value)), 
                        prop))
                cur_value += step

        return clazz

    def GenUnifromDistribution(self, min, max, numGroups, 
                               ramp, 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

        ramp.SetNumGroups(numGroups)

        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 ramp:

            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, prop1, prop2):
        self.prop1 = prop1
        self.prop2 = prop2

        self.count = 0

    def __iter__(self):
        return self

    def GetRamp(self):
        return self

    def SetNumGroups(self, num):

        if num <= 0:
            return False

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

        prop1 = self.prop1
        prop2 = self.prop2

        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

        return True

    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)

class MonochromaticRamp(CustomRamp):
    def __init__(self, start, end):
        sp = ClassGroupProperties()
        sp.SetLineColor(start)
        sp.SetFill(start)

        ep = ClassGroupProperties()
        ep.SetLineColor(end)
        ep.SetFill(end)

        CustomRamp.__init__(self, sp, ep)

class GreyRamp(MonochromaticRamp):
    def __init__(self):
        MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, 0))

class RedRamp(MonochromaticRamp):
    def __init__(self):
        MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(.8, 0, 0))

class GreenRamp(MonochromaticRamp):
    def __init__(self):
        MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, .8, 0))

class BlueRamp(MonochromaticRamp):
    def __init__(self):
        MonochromaticRamp.__init__(self, Color(1, 1, 1), Color(0, 0, .8))

class HotToColdRamp:

    def __iter__(self):
        return self
        
    def GetRamp(self):
        return self

    def SetNumGroups(self, num):
        if num < 0:
            return False

        self.num = float(num)
        self.index = 0

        return True

    def next(self):
        if self.index == self.num:
            raise StopIteration

        clr = [1.0, 1.0, 1.0]

        if self.index < (.25 * self.num):
            clr[0] = 0
            clr[1] = 4 * self.index / self.num
        elif self.index < (.5 * self.num):
            clr[0] = 0
            clr[2] = 1 + 4 * (.25 * self.num - self.index) / self.num
        elif self.index < (.75 * self.num):
            clr[0] = 4 * (self.index - .5 * self.num) / self.num
            clr[2] = 0
        else:
            clr[1] = 1 + 4 * (.75 * self.num - self.index) / self.num
            clr[2] = 0

        self.index += 1

        prop = ClassGroupProperties()
        prop.SetLineColor(Color(clr[0], clr[1], clr[2]))
        prop.SetFill(Color(clr[0], clr[1], clr[2]))

        return prop

#class Colors16Ramp:
#
    #def __iter__(self):
        #return self
#
    #def GetRamp(self):
        #return self
#
    #def SetNumGroups(self, num):
        #if num < 0:
            #return False
#
        #self.index = 0
#
        #return True

    
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision