Thuban/UI/classifier.py

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

"""Dialog for classifying how layers are displayed"""

__version__ = "$Revision$"

import copy

from wxPython.wx import *
from wxPython.grid import *

from Thuban import _
from Thuban.common import *
from Thuban.UI.common import *

from Thuban.Model.classification import * #Classification, ClassData

from Thuban.Model.color import Color

from Thuban.Model.layer import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT

ID_PROPERTY_SELECT = 4010
ID_CLASS_TABLE = 40011

ID_CLASSIFY_OK = 4001
ID_CLASSIFY_CANCEL = 4002
ID_CLASSIFY_ADD = 4003
ID_CLASSIFY_GENRANGE = 4004

COL_VISUAL = 0
COL_VALUE  = 1
COL_LABEL  = 2

#
# this is a silly work around to ensure that the table that is
# passed into SetTable is the same that is returned by GetTable
#
import weakref
class ClassGrid(wxGrid):

    def __init__(self, parent, layer):
        wxGrid.__init__(self, parent, ID_CLASS_TABLE, size = (300, 150))
        self.SetTable(
            ClassTable(layer.GetClassification(), layer.ShapeType(), self), 
            true)

    def SetCellRenderer(self, row, col):
        raise ValueError(_("Must not allow setting of renderer in ClassGrid!"))

    def SetTable(self, object, *attributes): 
        self.tableRef = weakref.ref(object) 
        return wxGrid.SetTable(self, object, *attributes) 

    def GetTable(self): 
        return self.tableRef() 


class ClassTable(wxPyGridTableBase):

    NUM_COLS = 3

    __col_labels = [_("Visual"), _("Value"), _("Label")]

    def __init__(self, clazz, shapeType, view = None):
        wxPyGridTableBase.__init__(self)
        self.SetView(view)
        self.tdata = []

        self.Reset(clazz, shapeType)

    def Reset(self, clazz, shapeType):

        self.GetView().BeginBatch()

        self.shapeType = shapeType
        self.renderer = ClassRenderer(self.shapeType)

        old_tdata = self.tdata

        self.tdata = []

        if clazz is None:
            clazz = Classification()

#       p = clazz.GetDefaultGroup()
#       np = ClassDataDefault(classData = p)
#       self.tdata.append([np, 'DEFAULT', np.GetLabel()])

#       for p in clazz.points.values():
#           np = ClassDataPoint(p.GetValue(), classData = p)
#           self.tdata.append([np, np.GetValue(), np.GetLabel()])

#       for p in clazz.ranges:
#           np = ClassDataRange(p.GetMin(), p.GetMax(), classData = p)
#           self.tdata.append([np, 
#                              '%s - %s' % (np.GetMin(), np.GetMax()), 
#                              np.GetLabel()])

        i = 0
        for p in clazz:
            np = copy.copy(p)
            self.__SetRow(i, np)
            i += 1

 
        self.modified = 0

        #
        # silly message processing for updates to the number of
        # rows and columns
        #
        curRows = len(old_tdata)
        newRows = len(self.tdata)
        if newRows > curRows:
            msg = wxGridTableMessage(self,
                        wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
                        newRows - curRows)    # how many
            self.GetView().ProcessTableMessage(msg)
        elif newRows < curRows:
            msg = wxGridTableMessage(self,
                        wxGRIDTABLE_NOTIFY_ROWS_DELETED,
                        curRows - newRows,    # position
                        curRows - newRows)    # how many
            self.GetView().ProcessTableMessage(msg)

        self.GetView().EndBatch()

    def __SetRow(self, row, group):

        if isinstance(group, ClassGroupDefault):
            data = [group, 'DEFAULT', group.GetLabel()]
        elif isinstance(group, ClassGroupSingleton):
            data = [group, group.GetValue(), group.GetLabel()]
        elif isinstance(group, ClassGroupRange):
            data = [group, 
                    '%s - %s' % (group.GetMin(), group.GetMax()), 
                    group.GetLabel()]

        if row >= len(self.tdata):
            self.tdata.append(data)
        else:
            self.tdata[row] = data

    def GetColLabelValue(self, col):
        return self.__col_labels[col]

    def GetRowLabelValue(self, row):
        data = self.tdata[row][COL_VISUAL]
        if isinstance(data, ClassGroupDefault): return _("Default")
        if isinstance(data, ClassGroupSingleton): return _("Singleton")
        if isinstance(data, ClassGroupRange): return _("Range")
        if isinstance(data, ClassGroupMap): return _("Map")

    def GetNumberRows(self):
        return len(self.tdata)

    def GetNumberCols(self):
        return self.NUM_COLS

    def IsEmptyCell(self, row, col):
        return 0

    def GetValue(self, row, col):
        return self.GetValueAsCustom(row, col, "")

    def SetValue(self, row, col, value):
        self.SetValueAsCustom(row, col, "", value)
        self.__Modified()
       
    def GetValueAsCustom(self, row, col, typeName):
        return self.tdata[row][col]

    def __ParseInput(self, value):
        """Try to determine what kind of input value is 
           (a single number or a range)
        """

        #
        # first try to take the input as a single number
        # if there's an exception try to break it into
        # a range seperated by a '-'. take care to ignore
        # a leading '-' as that could be for a negative number.
        # then try to parse the individual parts. if there
        # is an exception here, let it pass up to the calling
        # function.
        #
        try:
            return (Str2Num(value))
        except:
            i = value.find('-')
            if i == 0:
                i = value.find('-', 1)

            return (Str2Num(value[:i]), Str2Num(value[i+1:]))
            

    def SetValueAsCustom(self, row, col, typeName, value):
        data = self.tdata[row][COL_VISUAL]

        if col == COL_VISUAL:
            self.tdata[row][COL_VISUAL] = value
        elif col == COL_VALUE:
            if row != 0: # DefaultData row

                if isinstance(data, ClassGroupMap):
                    # something special
                    pass
                else: # POINT, RANGE
                    try:
                        dataInfo = self.__ParseInput(value)
                    except: pass
                        # bad input, ignore the request
                    else:

                        if len(dataInfo) == 1:
                            if not isinstance(data, ClassGroupSingleton):
                                ndata = ClassGroupSingleton(prop = data)
                            ndata.SetValue(dataInfo[1])
                        elif len(dataInfo) == 2:
                            if not isinstance(data, ClassGroupRange):
                                data = ClassDataRange(classData = data)
                            data.SetRange(dataInfo[1], dataInfo[2])

                        ndata.SetLabel(data.GetLabel())
                        self.__SetRow(row, ndata)

                        #self.tdata[row][COL_VISUAL] = data

                        self.GetView().Refresh()

        elif col == COL_LABEL:
            data.SetLabel(value)
            self.tdata[row][COL_LABEL] = data.GetLabel()
        else:
            raise ValueError(_("Invalid column request"))

        self.__Modified()

    def GetAttr(self, row, col, someExtraParameter):
        attr = wxGridCellAttr()
        #attr = wxPyGridTableBase.GetAttr(self, row, col, someExtraParameter)
 
        if col == COL_VISUAL:
            attr.SetRenderer(ClassRenderer(self.shapeType))
            attr.SetReadOnly()

        return attr

    def GetClassGroup(self, row):
        return self.tdata[row][COL_VISUAL]

    def __Modified(self):
        self.modified = 1

    def IsModified(self):
        return self.modified

    def AddNewDataRow(self):
        np = ClassDataPoint()
        self.tdata.append([np, np.GetValue(), np.GetLabel()])
        msg = wxGridTableMessage(self, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
        self.GetView().ProcessTableMessage(msg)
        self.GetView().Refresh()

class Classifier(wxDialog):
    
    def __init__(self, parent, layer):
        wxDialog.__init__(self, parent, -1, _("Classify"),
                          style = wxRESIZE_BORDER)

        self.layer = layer

        topBox = wxBoxSizer(wxVERTICAL)

        topBox.Add(wxStaticText(self, -1, _("Layer: %s") % layer.Title()),
            0, wxALIGN_LEFT | wxBOTTOM, 4) 
        topBox.Add(wxStaticText(self, -1, _("Type: %s") % layer.ShapeType()),
            0, wxALIGN_LEFT | wxBOTTOM, 4) 

        propertyBox = wxBoxSizer(wxHORIZONTAL)
        propertyBox.Add(wxStaticText(self, -1, _("Property: ")),
            0, wxALIGN_CENTER | wxALL, 4)

        self.properties = wxComboBox(self, ID_PROPERTY_SELECT, "",
                                     style = wxCB_READONLY)

        self.num_cols = layer.table.field_count()
        # just assume the first field in case one hasn't been
        # specified in the file.
        self.__cur_prop = 0 
        field = layer.GetClassification().GetField()
        for i in range(self.num_cols):
            type, name, len, decc = layer.table.field_info(i)
            if name == field:
                self.__cur_prop = i
            self.properties.Append(name)
            self.properties.SetClientData(i, None)

        self.properties.SetSelection(self.__cur_prop)
        propertyBox.Add(self.properties, 1, wxGROW|wxALL, 0)
        EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self.OnPropertySelect)

        topBox.Add(propertyBox, 0, wxGROW, 4)

        #
        # Classification data table
        #

        controlBox = wxBoxSizer(wxHORIZONTAL)
        self.classGrid = ClassGrid(self, layer)

        controlBox.Add(self.classGrid, 1, wxGROW, 0)

        controlButtonBox = wxBoxSizer(wxVERTICAL)
        controlButtonBox.Add(wxButton(self, ID_CLASSIFY_ADD, 
            _("Add")), 0, wxGROW | wxALL, 4)
        controlButtonBox.Add(wxButton(self, ID_CLASSIFY_GENRANGE, 
            _("Generate Ranges")), 0, wxGROW | wxALL, 4)

        controlBox.Add(controlButtonBox, 0, wxGROW, 10)
        topBox.Add(controlBox, 1, wxGROW, 10)

        EVT_BUTTON(self, ID_CLASSIFY_ADD, self.OnAdd)
        EVT_BUTTON(self, ID_CLASSIFY_GENRANGE, self.OnGenRange)
        EVT_GRID_CELL_LEFT_DCLICK(self.classGrid, self.OnCellDClick)

        #
        # Control buttons:
        #
        buttonBox = wxBoxSizer(wxHORIZONTAL)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
                      0, wxALL, 4)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
                      0, wxALL, 4)
        topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_BOTTOM, 10)

        EVT_BUTTON(self, ID_CLASSIFY_OK, self.OnOK)
        EVT_BUTTON(self, ID_CLASSIFY_CANCEL, self.OnCancel)

        self.SetAutoLayout(true)
        self.SetSizer(topBox)
        topBox.Fit(self)
        topBox.SetSizeHints(self) 

    def __BuildClassification(self, prop):

        clazz = Classification()
        clazz.SetField(self.properties.GetStringSelection())

        numRows = self.classGrid.GetNumberRows()

        if numRows > 0:
            table = self.classGrid.GetTable()
            clazz.SetDefaultGroup(table.GetClassGroup(0))

            for i in range(1, numRows):
                clazz.AddGroup(table.GetClassGroup(i))

        return clazz

    def OnPropertySelect(self, event): 
        self.properties.SetClientData(
            self.__cur_prop, self.__BuildClassification(self.__cur_prop))

        self.__cur_prop = self.properties.GetSelection()
        clazz = self.properties.GetClientData(self.__cur_prop)
        table = self.classGrid.GetTable()

        table.Reset(clazz, self.layer.ShapeType())

    def OnOK(self, event):
        """Put the data from the table into a new Classification and hand
           it to the layer.
        """

        clazz = self.properties.GetClientData(self.__cur_prop)

        #
        # only build the classification if there wasn't one to
        # to begin with or it has been modified
        #
        if clazz is None or self.classGrid.GetTable().IsModified():
            clazz = self.__BuildClassification(self.__cur_prop)

        clazz.SetLayer(self.layer)

        self.layer.SetClassification(clazz)

        self.EndModal(wxID_OK)

    def OnCancel(self, event):
        """Do nothing. The layer's current classification stays the same."""
        self.EndModal(wxID_CANCEL)


    def OnAdd(self, event): 
        self.classGrid.GetTable().AddNewDataRow()
        print "Classifier.OnAdd()"

    def OnGenRange(self, event):
        print "Classifier.OnGenRange()"

    def OnCellDClick(self, event):
        r = event.GetRow()
        c = event.GetCol()
        if c == COL_VISUAL:
            # XXX: getting the properties is only possible with non-Maps!!!
            group = self.classGrid.GetTable().GetValueAsCustom(r, c, None)
            prop = group.GetProperties()
            propDlg = SelectPropertiesDialog(NULL, prop, self.layer.ShapeType())
            if propDlg.ShowModal() == wxID_OK:
                new_prop = propDlg.GetClassGroupProperties()
                prop.SetStroke(new_prop.GetStroke())
                prop.SetStrokeWidth(new_prop.GetStrokeWidth())
                prop.SetFill(new_prop.GetFill())
                self.classGrid.Refresh()
            propDlg.Destroy()


ID_SELPROP_OK = 4001
ID_SELPROP_CANCEL = 4002
ID_SELPROP_SPINCTRL = 4002
ID_SELPROP_PREVIEW = 4003
ID_SELPROP_STROKECLR = 4004
ID_SELPROP_FILLCLR = 4005

class SelectPropertiesDialog(wxDialog):

    def __init__(self, parent, prop, shapeType):
        wxDialog.__init__(self, parent, -1, _("Select Properties"),
                          style = wxRESIZE_BORDER)

        self.prop = ClassGroupProperties(prop)

        topBox = wxBoxSizer(wxVERTICAL)

        itemBox = wxBoxSizer(wxHORIZONTAL)

        # preview box
        previewBox = wxBoxSizer(wxVERTICAL)
        previewBox.Add(wxStaticText(self, -1, _("Preview:")),
            0, wxALIGN_LEFT | wxALL, 4)
        self.previewer = ClassDataPreviewer(None, self.prop, shapeType, 
                                            self, ID_SELPROP_PREVIEW, (40, 40))
        previewBox.Add(self.previewer, 1, wxGROW, 15)

        itemBox.Add(previewBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)

        # control box
        ctrlBox = wxBoxSizer(wxVERTICAL)
        ctrlBox.Add(
            wxButton(self, ID_SELPROP_STROKECLR, "Change Stroke Color"),
            0, wxALIGN_CENTER_HORIZONTAL | wxALL | wxGROW, 4)
        EVT_BUTTON(self, ID_SELPROP_STROKECLR, self.OnChangeStrokeColor)

        if shapeType != SHAPETYPE_ARC:
            ctrlBox.Add(
                wxButton(self, ID_SELPROP_FILLCLR, "Change Fill Color"),
                0, wxALIGN_LEFT | wxALL | wxGROW, 4)
            EVT_BUTTON(self, ID_SELPROP_FILLCLR, self.OnChangeFillColor)

        spinBox = wxBoxSizer(wxHORIZONTAL)
        spinBox.Add(wxStaticText(self, -1, _("Stroke Width: ")),
                0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 4) 
        self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL, 
                                   min=1, max=10, 
                                   value=str(prop.GetStrokeWidth()),
                                   initial=prop.GetStrokeWidth())

        EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self.OnSpin)

        spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT | wxALL, 4) 

        ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT | wxALL, 0)
        itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT | wxALL | wxGROW, 0)
        topBox.Add(itemBox, 1, wxALIGN_LEFT | wxALL | wxGROW, 0)


        #
        # Control buttons:
        #
        buttonBox = wxBoxSizer(wxHORIZONTAL)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
                      0, wxALL, 4)
        buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
                      0, wxALL, 4)
        topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_BOTTOM, 10)
                                                                                
        EVT_BUTTON(self, ID_SELPROP_OK, self.OnOK)
        EVT_BUTTON(self, ID_SELPROP_CANCEL, self.OnCancel)
                                                                                
        self.SetAutoLayout(true)
        self.SetSizer(topBox)
        topBox.Fit(self)
        topBox.SetSizeHints(self)

    def OnOK(self, event):
        self.EndModal(wxID_OK)

    def OnCancel(self, event):
        self.EndModal(wxID_CANCEL)

    def OnSpin(self, event):
        self.prop.SetStrokeWidth(self.spinCtrl.GetValue())
        self.previewer.Refresh()

    def __GetColor(self, cur):
        dialog = wxColourDialog(self)
        dialog.GetColourData().SetColour(Color2wxColour(cur))
        ret = None
        if dialog.ShowModal() == wxID_OK:
            ret = wxColour2Color(dialog.GetColourData().GetColour())

        dialog.Destroy()

        return ret
        
    def OnChangeStrokeColor(self, event):
        clr = self.__GetColor(self.prop.GetStroke())
        if clr is not None:
            self.prop.SetStroke(clr)
        self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer

    def OnChangeFillColor(self, event):
        clr = self.__GetColor(self.prop.GetFill())
        if clr is not None:
            self.prop.SetFill(clr)
        self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer

    def GetClassGroupProperties(self):
        return self.prop


class ClassDataPreviewer(wxWindow):

    def __init__(self, rect, prop, shapeType, 
                       parent = None, id = -1, size = wxDefaultSize):
        if parent is not None:
            wxWindow.__init__(self, parent, id, size=size)
            EVT_PAINT(self, self.OnPaint)

        self.rect = rect
        self.prop = prop
        self.shapeType = shapeType

    def OnPaint(self, event):
        dc = wxPaintDC(self)

        # XXX: this doesn't seem to be having an effect:
        dc.DestroyClippingRegion() 

        self.Draw(dc, None)

    def Draw(self, dc, rect, prop = None, shapeType = None):

        if prop is None: prop = self.prop
        if shapeType is None: shapeType = self.shapeType

        if rect is None:
            x = y = 0
            w, h = self.GetClientSizeTuple()
        else:
            x = rect.GetX()
            y = rect.GetY()
            w = rect.GetWidth()
            h = rect.GetHeight()

        stroke = prop.GetStroke()
        if stroke is Color.None:
            pen = wxTRANSPARENT_PEN
        else:
            pen = wxPen(Color2wxColour(stroke),
                        prop.GetStrokeWidth(),
                        wxSOLID)

        stroke = prop.GetFill()
        if stroke is Color.None:
            brush = wxTRANSPARENT_BRUSH
        else:
            brush = wxBrush(Color2wxColour(stroke), wxSOLID)

        dc.SetPen(pen)
        dc.SetBrush(brush)

        if shapeType == SHAPETYPE_ARC:
            dc.DrawSpline([wxPoint(x, y + h),
                           wxPoint(x + w/2, y + h/4),
                           wxPoint(x + w/2, y + h/4*3),
                           wxPoint(x + w, y)])

        elif shapeType == SHAPETYPE_POINT or \
             shapeType == SHAPETYPE_POLYGON:

            dc.DrawCircle(x + w/2, y + h/2,
                          (min(w, h) - prop.GetStrokeWidth())/2)

class ClassRenderer(wxPyGridCellRenderer):

    def __init__(self, shapeType):
        wxPyGridCellRenderer.__init__(self)
        self.previewer = ClassDataPreviewer(None, None, shapeType)

    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
        data = grid.GetTable().GetValueAsCustom(row, col, "")


        dc.SetClippingRegion(rect.GetX(), rect.GetY(), 
                             rect.GetWidth(), rect.GetHeight())
        dc.SetPen(wxPen(wxLIGHT_GREY))
        dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
        dc.DrawRectangle(rect.GetX(), rect.GetY(), 
                         rect.GetWidth(), rect.GetHeight())

        if not isinstance(data, ClassGroupMap):
            self.previewer.Draw(dc, rect, data.GetProperties())

        if isSelected:
            dc.SetPen(wxPen(wxColour(0 * 255, 0 * 255, 0 * 255),
                      4, wxSOLID))
            dc.SetBrush(wxTRANSPARENT_BRUSH)
            dc.DrawRectangle(rect.GetX(), rect.GetY(), 
                             rect.GetWidth(), rect.GetHeight())

        dc.DestroyClippingRegion()

1	jonathan	372	# Copyright (c) 2001 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			"""Dialog for classifying how layers are displayed"""
9
10			__version__ = "$Revision$"
11
12	jonathan	376	import copy
13
14	jonathan	372	from wxPython.wx import *
15			from wxPython.grid import *
16
17	jan	374	from Thuban import _
18	jonathan	415	from Thuban.common import *
19	jonathan	441	from Thuban.UI.common import *
20	jan	374
21	jonathan	415	from Thuban.Model.classification import * #Classification, ClassData
22	jonathan	392
23	jonathan	415	from Thuban.Model.color import Color
24
25	jonathan	392	from Thuban.Model.layer import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
26
27	jonathan	372	ID_PROPERTY_SELECT = 4010
28			ID_CLASS_TABLE = 40011
29
30			ID_CLASSIFY_OK = 4001
31			ID_CLASSIFY_CANCEL = 4002
32	jonathan	415	ID_CLASSIFY_ADD = 4003
33			ID_CLASSIFY_GENRANGE = 4004
34	jonathan	372
35	jonathan	415	COL_VISUAL = 0
36			COL_VALUE = 1
37			COL_LABEL = 2
38
39			#
40			# this is a silly work around to ensure that the table that is
41			# passed into SetTable is the same that is returned by GetTable
42			#
43			import weakref
44			class ClassGrid(wxGrid):
45
46			def __init__(self, parent, layer):
47			wxGrid.__init__(self, parent, ID_CLASS_TABLE, size = (300, 150))
48			self.SetTable(
49			ClassTable(layer.GetClassification(), layer.ShapeType(), self),
50			true)
51
52			def SetCellRenderer(self, row, col):
53			raise ValueError(_("Must not allow setting of renderer in ClassGrid!"))
54
55			def SetTable(self, object, *attributes):
56			self.tableRef = weakref.ref(object)
57			return wxGrid.SetTable(self, object, *attributes)
58
59			def GetTable(self):
60			return self.tableRef()
61
62
63	jonathan	376	class ClassTable(wxPyGridTableBase):
64
65	jonathan	415	NUM_COLS = 3
66
67			__col_labels = [_("Visual"), _("Value"), _("Label")]
68
69			def __init__(self, clazz, shapeType, view = None):
70	jonathan	376	wxPyGridTableBase.__init__(self)
71	jonathan	415	self.SetView(view)
72			self.tdata = []
73	jonathan	376
74	jonathan	415	self.Reset(clazz, shapeType)
75
76			def Reset(self, clazz, shapeType):
77
78			self.GetView().BeginBatch()
79
80			self.shapeType = shapeType
81			self.renderer = ClassRenderer(self.shapeType)
82
83			old_tdata = self.tdata
84
85	jonathan	376	self.tdata = []
86
87	jonathan	415	if clazz is None:
88			clazz = Classification()
89	jonathan	392
90	jonathan	441	# p = clazz.GetDefaultGroup()
91			# np = ClassDataDefault(classData = p)
92			# self.tdata.append([np, 'DEFAULT', np.GetLabel()])
93	jonathan	376
94	jonathan	441	# for p in clazz.points.values():
95			# np = ClassDataPoint(p.GetValue(), classData = p)
96			# self.tdata.append([np, np.GetValue(), np.GetLabel()])
97	jonathan	376
98	jonathan	441	# for p in clazz.ranges:
99			# np = ClassDataRange(p.GetMin(), p.GetMax(), classData = p)
100			# self.tdata.append([np,
101			# '%s - %s' % (np.GetMin(), np.GetMax()),
102			# np.GetLabel()])
103	jonathan	415
104	jonathan	441	i = 0
105			for p in clazz:
106			np = copy.copy(p)
107			self.__SetRow(i, np)
108			i += 1
109
110
111	jonathan	415	self.modified = 0
112
113			#
114			# silly message processing for updates to the number of
115			# rows and columns
116			#
117			curRows = len(old_tdata)
118			newRows = len(self.tdata)
119			if newRows > curRows:
120			msg = wxGridTableMessage(self,
121			wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
122			newRows - curRows) # how many
123			self.GetView().ProcessTableMessage(msg)
124			elif newRows < curRows:
125			msg = wxGridTableMessage(self,
126			wxGRIDTABLE_NOTIFY_ROWS_DELETED,
127			curRows - newRows, # position
128			curRows - newRows) # how many
129			self.GetView().ProcessTableMessage(msg)
130
131			self.GetView().EndBatch()
132
133	jonathan	441	def __SetRow(self, row, group):
134
135			if isinstance(group, ClassGroupDefault):
136			data = [group, 'DEFAULT', group.GetLabel()]
137			elif isinstance(group, ClassGroupSingleton):
138			data = [group, group.GetValue(), group.GetLabel()]
139			elif isinstance(group, ClassGroupRange):
140			data = [group,
141			'%s - %s' % (group.GetMin(), group.GetMax()),
142			group.GetLabel()]
143
144			if row >= len(self.tdata):
145			self.tdata.append(data)
146			else:
147			self.tdata[row] = data
148
149	jonathan	415	def GetColLabelValue(self, col):
150			return self.__col_labels[col]
151
152			def GetRowLabelValue(self, row):
153			data = self.tdata[row][COL_VISUAL]
154	jonathan	441	if isinstance(data, ClassGroupDefault): return _("Default")
155			if isinstance(data, ClassGroupSingleton): return _("Singleton")
156			if isinstance(data, ClassGroupRange): return _("Range")
157			if isinstance(data, ClassGroupMap): return _("Map")
158	jonathan	415
159	jonathan	376	def GetNumberRows(self):
160			return len(self.tdata)
161
162			def GetNumberCols(self):
163	jonathan	415	return self.NUM_COLS
164	jonathan	376
165			def IsEmptyCell(self, row, col):
166	jonathan	415	return 0
167	jonathan	376
168			def GetValue(self, row, col):
169	jonathan	415	return self.GetValueAsCustom(row, col, "")
170	jonathan	376
171			def SetValue(self, row, col, value):
172	jonathan	415	self.SetValueAsCustom(row, col, "", value)
173			self.__Modified()
174
175	jonathan	392	def GetValueAsCustom(self, row, col, typeName):
176			return self.tdata[row][col]
177	jonathan	376
178	jonathan	415	def __ParseInput(self, value):
179			"""Try to determine what kind of input value is
180			(a single number or a range)
181			"""
182	jonathan	392
183	jonathan	415	#
184			# first try to take the input as a single number
185			# if there's an exception try to break it into
186			# a range seperated by a '-'. take care to ignore
187			# a leading '-' as that could be for a negative number.
188			# then try to parse the individual parts. if there
189			# is an exception here, let it pass up to the calling
190			# function.
191			#
192			try:
193	jonathan	441	return (Str2Num(value))
194	jonathan	415	except:
195			i = value.find('-')
196			if i == 0:
197			i = value.find('-', 1)
198
199	jonathan	441	return (Str2Num(value[:i]), Str2Num(value[i+1:]))
200	jonathan	415
201
202			def SetValueAsCustom(self, row, col, typeName, value):
203			data = self.tdata[row][COL_VISUAL]
204
205			if col == COL_VISUAL:
206			self.tdata[row][COL_VISUAL] = value
207			elif col == COL_VALUE:
208			if row != 0: # DefaultData row
209
210	jonathan	441	if isinstance(data, ClassGroupMap):
211	jonathan	415	# something special
212			pass
213			else: # POINT, RANGE
214			try:
215			dataInfo = self.__ParseInput(value)
216			except: pass
217			# bad input, ignore the request
218			else:
219
220	jonathan	441	if len(dataInfo) == 1:
221			if not isinstance(data, ClassGroupSingleton):
222			ndata = ClassGroupSingleton(prop = data)
223			ndata.SetValue(dataInfo[1])
224			elif len(dataInfo) == 2:
225			if not isinstance(data, ClassGroupRange):
226	jonathan	415	data = ClassDataRange(classData = data)
227			data.SetRange(dataInfo[1], dataInfo[2])
228
229	jonathan	441	ndata.SetLabel(data.GetLabel())
230			self.__SetRow(row, ndata)
231	jonathan	415
232	jonathan	441	#self.tdata[row][COL_VISUAL] = data
233
234	jonathan	430	self.GetView().Refresh()
235	jonathan	415
236			elif col == COL_LABEL:
237			data.SetLabel(value)
238			self.tdata[row][COL_LABEL] = data.GetLabel()
239			else:
240			raise ValueError(_("Invalid column request"))
241
242			self.__Modified()
243
244			def GetAttr(self, row, col, someExtraParameter):
245			attr = wxGridCellAttr()
246			#attr = wxPyGridTableBase.GetAttr(self, row, col, someExtraParameter)
247
248			if col == COL_VISUAL:
249			attr.SetRenderer(ClassRenderer(self.shapeType))
250			attr.SetReadOnly()
251
252			return attr
253
254	jonathan	441	def GetClassGroup(self, row):
255	jonathan	415	return self.tdata[row][COL_VISUAL]
256
257			def __Modified(self):
258			self.modified = 1
259
260			def IsModified(self):
261			return self.modified
262
263			def AddNewDataRow(self):
264			np = ClassDataPoint()
265			self.tdata.append([np, np.GetValue(), np.GetLabel()])
266			msg = wxGridTableMessage(self, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
267			self.GetView().ProcessTableMessage(msg)
268	jonathan	430	self.GetView().Refresh()
269	jonathan	415
270	jonathan	372	class Classifier(wxDialog):
271
272			def __init__(self, parent, layer):
273	jan	374	wxDialog.__init__(self, parent, -1, _("Classify"),
274	jonathan	372	style = wxRESIZE_BORDER)
275
276	jonathan	415	self.layer = layer
277
278	jonathan	372	topBox = wxBoxSizer(wxVERTICAL)
279
280	jonathan	415	topBox.Add(wxStaticText(self, -1, _("Layer: %s") % layer.Title()),
281			0, wxALIGN_LEFT \| wxBOTTOM, 4)
282			topBox.Add(wxStaticText(self, -1, _("Type: %s") % layer.ShapeType()),
283			0, wxALIGN_LEFT \| wxBOTTOM, 4)
284
285	jonathan	372	propertyBox = wxBoxSizer(wxHORIZONTAL)
286	jonathan	415	propertyBox.Add(wxStaticText(self, -1, _("Property: ")),
287	jonathan	372	0, wxALIGN_CENTER \| wxALL, 4)
288
289			self.properties = wxComboBox(self, ID_PROPERTY_SELECT, "",
290			style = wxCB_READONLY)
291
292			self.num_cols = layer.table.field_count()
293	jonathan	441	# just assume the first field in case one hasn't been
294			# specified in the file.
295			self.__cur_prop = 0
296	jonathan	415	field = layer.GetClassification().GetField()
297	jonathan	372	for i in range(self.num_cols):
298			type, name, len, decc = layer.table.field_info(i)
299	jonathan	415	if name == field:
300			self.__cur_prop = i
301	jonathan	372	self.properties.Append(name)
302	jonathan	415	self.properties.SetClientData(i, None)
303	jonathan	372
304	jonathan	415	self.properties.SetSelection(self.__cur_prop)
305			propertyBox.Add(self.properties, 1, wxGROW\|wxALL, 0)
306	jonathan	372	EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self.OnPropertySelect)
307
308	jonathan	376	topBox.Add(propertyBox, 0, wxGROW, 4)
309	jonathan	372
310			#
311			# Classification data table
312			#
313
314	jonathan	415	controlBox = wxBoxSizer(wxHORIZONTAL)
315			self.classGrid = ClassGrid(self, layer)
316	jonathan	376
317	jonathan	415	controlBox.Add(self.classGrid, 1, wxGROW, 0)
318	jonathan	376
319	jonathan	415	controlButtonBox = wxBoxSizer(wxVERTICAL)
320			controlButtonBox.Add(wxButton(self, ID_CLASSIFY_ADD,
321			_("Add")), 0, wxGROW \| wxALL, 4)
322			controlButtonBox.Add(wxButton(self, ID_CLASSIFY_GENRANGE,
323			_("Generate Ranges")), 0, wxGROW \| wxALL, 4)
324	jonathan	372
325	jonathan	415	controlBox.Add(controlButtonBox, 0, wxGROW, 10)
326			topBox.Add(controlBox, 1, wxGROW, 10)
327
328			EVT_BUTTON(self, ID_CLASSIFY_ADD, self.OnAdd)
329			EVT_BUTTON(self, ID_CLASSIFY_GENRANGE, self.OnGenRange)
330			EVT_GRID_CELL_LEFT_DCLICK(self.classGrid, self.OnCellDClick)
331
332	jonathan	372	#
333			# Control buttons:
334			#
335			buttonBox = wxBoxSizer(wxHORIZONTAL)
336	jan	374	buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
337	jonathan	372	0, wxALL, 4)
338	jan	374	buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
339	jonathan	372	0, wxALL, 4)
340			topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL\|wxALIGN_BOTTOM, 10)
341
342			EVT_BUTTON(self, ID_CLASSIFY_OK, self.OnOK)
343			EVT_BUTTON(self, ID_CLASSIFY_CANCEL, self.OnCancel)
344
345			self.SetAutoLayout(true)
346			self.SetSizer(topBox)
347			topBox.Fit(self)
348			topBox.SetSizeHints(self)
349
350	jonathan	415	def __BuildClassification(self, prop):
351
352			clazz = Classification()
353			clazz.SetField(self.properties.GetStringSelection())
354
355			numRows = self.classGrid.GetNumberRows()
356
357			if numRows > 0:
358			table = self.classGrid.GetTable()
359	jonathan	441	clazz.SetDefaultGroup(table.GetClassGroup(0))
360	jonathan	415
361			for i in range(1, numRows):
362	jonathan	441	clazz.AddGroup(table.GetClassGroup(i))
363	jonathan	415
364			return clazz
365
366			def OnPropertySelect(self, event):
367			self.properties.SetClientData(
368			self.__cur_prop, self.__BuildClassification(self.__cur_prop))
369
370			self.__cur_prop = self.properties.GetSelection()
371			clazz = self.properties.GetClientData(self.__cur_prop)
372			table = self.classGrid.GetTable()
373
374			table.Reset(clazz, self.layer.ShapeType())
375
376			def OnOK(self, event):
377			"""Put the data from the table into a new Classification and hand
378			it to the layer.
379			"""
380
381			clazz = self.properties.GetClientData(self.__cur_prop)
382
383			#
384			# only build the classification if there wasn't one to
385			# to begin with or it has been modified
386			#
387			if clazz is None or self.classGrid.GetTable().IsModified():
388			clazz = self.__BuildClassification(self.__cur_prop)
389
390			clazz.SetLayer(self.layer)
391
392			self.layer.SetClassification(clazz)
393
394			self.EndModal(wxID_OK)
395
396			def OnCancel(self, event):
397			"""Do nothing. The layer's current classification stays the same."""
398			self.EndModal(wxID_CANCEL)
399
400
401			def OnAdd(self, event):
402			self.classGrid.GetTable().AddNewDataRow()
403			print "Classifier.OnAdd()"
404
405			def OnGenRange(self, event):
406			print "Classifier.OnGenRange()"
407
408			def OnCellDClick(self, event):
409			r = event.GetRow()
410			c = event.GetCol()
411			if c == COL_VISUAL:
412	jonathan	441	# XXX: getting the properties is only possible with non-Maps!!!
413			group = self.classGrid.GetTable().GetValueAsCustom(r, c, None)
414			prop = group.GetProperties()
415	jonathan	415	propDlg = SelectPropertiesDialog(NULL, prop, self.layer.ShapeType())
416			if propDlg.ShowModal() == wxID_OK:
417	jonathan	441	new_prop = propDlg.GetClassGroupProperties()
418	jonathan	415	prop.SetStroke(new_prop.GetStroke())
419			prop.SetStrokeWidth(new_prop.GetStrokeWidth())
420			prop.SetFill(new_prop.GetFill())
421	jonathan	430	self.classGrid.Refresh()
422	jonathan	415	propDlg.Destroy()
423
424
425			ID_SELPROP_OK = 4001
426			ID_SELPROP_CANCEL = 4002
427			ID_SELPROP_SPINCTRL = 4002
428	jonathan	430	ID_SELPROP_PREVIEW = 4003
429			ID_SELPROP_STROKECLR = 4004
430			ID_SELPROP_FILLCLR = 4005
431	jonathan	415
432			class SelectPropertiesDialog(wxDialog):
433
434			def __init__(self, parent, prop, shapeType):
435			wxDialog.__init__(self, parent, -1, _("Select Properties"),
436			style = wxRESIZE_BORDER)
437
438	jonathan	441	self.prop = ClassGroupProperties(prop)
439	jonathan	415
440	jonathan	430	topBox = wxBoxSizer(wxVERTICAL)
441	jonathan	415
442	jonathan	430	itemBox = wxBoxSizer(wxHORIZONTAL)
443
444			# preview box
445			previewBox = wxBoxSizer(wxVERTICAL)
446			previewBox.Add(wxStaticText(self, -1, _("Preview:")),
447			0, wxALIGN_LEFT \| wxALL, 4)
448			self.previewer = ClassDataPreviewer(None, self.prop, shapeType,
449			self, ID_SELPROP_PREVIEW, (40, 40))
450			previewBox.Add(self.previewer, 1, wxGROW, 15)
451
452			itemBox.Add(previewBox, 1, wxALIGN_LEFT \| wxALL \| wxGROW, 0)
453
454			# control box
455			ctrlBox = wxBoxSizer(wxVERTICAL)
456			ctrlBox.Add(
457			wxButton(self, ID_SELPROP_STROKECLR, "Change Stroke Color"),
458			0, wxALIGN_CENTER_HORIZONTAL \| wxALL \| wxGROW, 4)
459			EVT_BUTTON(self, ID_SELPROP_STROKECLR, self.OnChangeStrokeColor)
460
461			if shapeType != SHAPETYPE_ARC:
462			ctrlBox.Add(
463			wxButton(self, ID_SELPROP_FILLCLR, "Change Fill Color"),
464			0, wxALIGN_LEFT \| wxALL \| wxGROW, 4)
465			EVT_BUTTON(self, ID_SELPROP_FILLCLR, self.OnChangeFillColor)
466
467	jonathan	415	spinBox = wxBoxSizer(wxHORIZONTAL)
468			spinBox.Add(wxStaticText(self, -1, _("Stroke Width: ")),
469	jonathan	430	0, wxALIGN_LEFT \| wxALIGN_CENTER_VERTICAL \| wxALL, 4)
470	jonathan	415	self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL,
471			min=1, max=10,
472			value=str(prop.GetStrokeWidth()),
473			initial=prop.GetStrokeWidth())
474
475			EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self.OnSpin)
476
477			spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT \| wxALL, 4)
478
479	jonathan	430	ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT \| wxALL, 0)
480			itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT \| wxALL \| wxGROW, 0)
481			topBox.Add(itemBox, 1, wxALIGN_LEFT \| wxALL \| wxGROW, 0)
482	jonathan	415
483
484			#
485			# Control buttons:
486			#
487			buttonBox = wxBoxSizer(wxHORIZONTAL)
488			buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
489			0, wxALL, 4)
490			buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
491			0, wxALL, 4)
492			topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL\|wxALIGN_BOTTOM, 10)
493
494			EVT_BUTTON(self, ID_SELPROP_OK, self.OnOK)
495			EVT_BUTTON(self, ID_SELPROP_CANCEL, self.OnCancel)
496
497			self.SetAutoLayout(true)
498			self.SetSizer(topBox)
499			topBox.Fit(self)
500			topBox.SetSizeHints(self)
501
502	jonathan	372	def OnOK(self, event):
503			self.EndModal(wxID_OK)
504
505			def OnCancel(self, event):
506			self.EndModal(wxID_CANCEL)
507
508	jonathan	415	def OnSpin(self, event):
509			self.prop.SetStrokeWidth(self.spinCtrl.GetValue())
510	jonathan	430	self.previewer.Refresh()
511	jonathan	392
512	jonathan	430	def __GetColor(self, cur):
513			dialog = wxColourDialog(self)
514			dialog.GetColourData().SetColour(Color2wxColour(cur))
515			ret = None
516			if dialog.ShowModal() == wxID_OK:
517			ret = wxColour2Color(dialog.GetColourData().GetColour())
518
519			dialog.Destroy()
520
521			return ret
522
523			def OnChangeStrokeColor(self, event):
524			clr = self.__GetColor(self.prop.GetStroke())
525			if clr is not None:
526			self.prop.SetStroke(clr)
527			self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer
528
529			def OnChangeFillColor(self, event):
530			clr = self.__GetColor(self.prop.GetFill())
531			if clr is not None:
532			self.prop.SetFill(clr)
533			self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer
534
535	jonathan	441	def GetClassGroupProperties(self):
536	jonathan	415	return self.prop
537	jonathan	392
538
539	jonathan	430	class ClassDataPreviewer(wxWindow):
540	jonathan	415
541	jonathan	441	def __init__(self, rect, prop, shapeType,
542	jonathan	430	parent = None, id = -1, size = wxDefaultSize):
543			if parent is not None:
544			wxWindow.__init__(self, parent, id, size=size)
545			EVT_PAINT(self, self.OnPaint)
546	jonathan	415
547	jonathan	430	self.rect = rect
548	jonathan	441	self.prop = prop
549	jonathan	430	self.shapeType = shapeType
550
551			def OnPaint(self, event):
552			dc = wxPaintDC(self)
553
554			# XXX: this doesn't seem to be having an effect:
555			dc.DestroyClippingRegion()
556
557			self.Draw(dc, None)
558
559	jonathan	441	def Draw(self, dc, rect, prop = None, shapeType = None):
560	jonathan	430
561	jonathan	441	if prop is None: prop = self.prop
562	jonathan	430	if shapeType is None: shapeType = self.shapeType
563
564			if rect is None:
565			x = y = 0
566			w, h = self.GetClientSizeTuple()
567			else:
568			x = rect.GetX()
569			y = rect.GetY()
570			w = rect.GetWidth()
571			h = rect.GetHeight()
572
573	jonathan	441	stroke = prop.GetStroke()
574	jonathan	415	if stroke is Color.None:
575	jonathan	392	pen = wxTRANSPARENT_PEN
576			else:
577	jonathan	430	pen = wxPen(Color2wxColour(stroke),
578	jonathan	441	prop.GetStrokeWidth(),
579	jonathan	392	wxSOLID)
580
581	jonathan	441	stroke = prop.GetFill()
582	jonathan	415	if stroke is Color.None:
583	jonathan	392	brush = wxTRANSPARENT_BRUSH
584			else:
585	jonathan	430	brush = wxBrush(Color2wxColour(stroke), wxSOLID)
586	jonathan	392
587			dc.SetPen(pen)
588			dc.SetBrush(brush)
589
590	jonathan	415	if shapeType == SHAPETYPE_ARC:
591	jonathan	430	dc.DrawSpline([wxPoint(x, y + h),
592			wxPoint(x + w/2, y + h/4),
593			wxPoint(x + w/2, y + h/4*3),
594			wxPoint(x + w, y)])
595	jonathan	392
596	jonathan	415	elif shapeType == SHAPETYPE_POINT or \
597			shapeType == SHAPETYPE_POLYGON:
598
599	jonathan	430	dc.DrawCircle(x + w/2, y + h/2,
600	jonathan	441	(min(w, h) - prop.GetStrokeWidth())/2)
601	jonathan	392
602	jonathan	415	class ClassRenderer(wxPyGridCellRenderer):
603
604			def __init__(self, shapeType):
605			wxPyGridCellRenderer.__init__(self)
606	jonathan	430	self.previewer = ClassDataPreviewer(None, None, shapeType)
607	jonathan	415
608			def Draw(self, grid, attr, dc, rect, row, col, isSelected):
609			data = grid.GetTable().GetValueAsCustom(row, col, "")
610
611
612			dc.SetClippingRegion(rect.GetX(), rect.GetY(),
613			rect.GetWidth(), rect.GetHeight())
614			dc.SetPen(wxPen(wxLIGHT_GREY))
615			dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
616			dc.DrawRectangle(rect.GetX(), rect.GetY(),
617			rect.GetWidth(), rect.GetHeight())
618
619	jonathan	441	if not isinstance(data, ClassGroupMap):
620			self.previewer.Draw(dc, rect, data.GetProperties())
621	jonathan	415
622			if isSelected:
623			dc.SetPen(wxPen(wxColour(0 * 255, 0 * 255, 0 * 255),
624			4, wxSOLID))
625			dc.SetBrush(wxTRANSPARENT_BRUSH)
626			dc.DrawRectangle(rect.GetX(), rect.GetY(),
627			rect.GetWidth(), rect.GetHeight())
628
629	jonathan	392	dc.DestroyClippingRegion()
630
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision