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:

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

                        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	444	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	444	ndata = data
221	jonathan	441	if len(dataInfo) == 1:
222			if not isinstance(data, ClassGroupSingleton):
223			ndata = ClassGroupSingleton(prop = data)
224	jonathan	444	ndata.SetValue(dataInfo[0])
225	jonathan	441	elif len(dataInfo) == 2:
226			if not isinstance(data, ClassGroupRange):
227	jonathan	415	data = ClassDataRange(classData = data)
228	jonathan	444	data.SetRange(dataInfo[0], dataInfo[1])
229	jonathan	415
230	jonathan	441	ndata.SetLabel(data.GetLabel())
231			self.__SetRow(row, ndata)
232	jonathan	415
233	jonathan	441	#self.tdata[row][COL_VISUAL] = data
234
235	jonathan	430	self.GetView().Refresh()
236	jonathan	415
237			elif col == COL_LABEL:
238			data.SetLabel(value)
239			self.tdata[row][COL_LABEL] = data.GetLabel()
240			else:
241			raise ValueError(_("Invalid column request"))
242
243			self.__Modified()
244
245			def GetAttr(self, row, col, someExtraParameter):
246			attr = wxGridCellAttr()
247			#attr = wxPyGridTableBase.GetAttr(self, row, col, someExtraParameter)
248
249			if col == COL_VISUAL:
250			attr.SetRenderer(ClassRenderer(self.shapeType))
251			attr.SetReadOnly()
252
253			return attr
254
255	jonathan	441	def GetClassGroup(self, row):
256	jonathan	415	return self.tdata[row][COL_VISUAL]
257
258			def __Modified(self):
259			self.modified = 1
260
261			def IsModified(self):
262			return self.modified
263
264			def AddNewDataRow(self):
265			np = ClassDataPoint()
266			self.tdata.append([np, np.GetValue(), np.GetLabel()])
267			msg = wxGridTableMessage(self, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
268			self.GetView().ProcessTableMessage(msg)
269	jonathan	430	self.GetView().Refresh()
270	jonathan	415
271	jonathan	372	class Classifier(wxDialog):
272
273			def __init__(self, parent, layer):
274	jan	374	wxDialog.__init__(self, parent, -1, _("Classify"),
275	jonathan	372	style = wxRESIZE_BORDER)
276
277	jonathan	415	self.layer = layer
278
279	jonathan	372	topBox = wxBoxSizer(wxVERTICAL)
280
281	jonathan	415	topBox.Add(wxStaticText(self, -1, _("Layer: %s") % layer.Title()),
282			0, wxALIGN_LEFT \| wxBOTTOM, 4)
283			topBox.Add(wxStaticText(self, -1, _("Type: %s") % layer.ShapeType()),
284			0, wxALIGN_LEFT \| wxBOTTOM, 4)
285
286	jonathan	372	propertyBox = wxBoxSizer(wxHORIZONTAL)
287	jonathan	415	propertyBox.Add(wxStaticText(self, -1, _("Property: ")),
288	jonathan	372	0, wxALIGN_CENTER \| wxALL, 4)
289
290			self.properties = wxComboBox(self, ID_PROPERTY_SELECT, "",
291			style = wxCB_READONLY)
292
293			self.num_cols = layer.table.field_count()
294	jonathan	441	# just assume the first field in case one hasn't been
295			# specified in the file.
296			self.__cur_prop = 0
297	jonathan	415	field = layer.GetClassification().GetField()
298	jonathan	372	for i in range(self.num_cols):
299			type, name, len, decc = layer.table.field_info(i)
300	jonathan	415	if name == field:
301			self.__cur_prop = i
302	jonathan	372	self.properties.Append(name)
303	jonathan	415	self.properties.SetClientData(i, None)
304	jonathan	372
305	jonathan	415	self.properties.SetSelection(self.__cur_prop)
306			propertyBox.Add(self.properties, 1, wxGROW\|wxALL, 0)
307	jonathan	372	EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self.OnPropertySelect)
308
309	jonathan	376	topBox.Add(propertyBox, 0, wxGROW, 4)
310	jonathan	372
311			#
312			# Classification data table
313			#
314
315	jonathan	415	controlBox = wxBoxSizer(wxHORIZONTAL)
316			self.classGrid = ClassGrid(self, layer)
317	jonathan	376
318	jonathan	415	controlBox.Add(self.classGrid, 1, wxGROW, 0)
319	jonathan	376
320	jonathan	415	controlButtonBox = wxBoxSizer(wxVERTICAL)
321			controlButtonBox.Add(wxButton(self, ID_CLASSIFY_ADD,
322			_("Add")), 0, wxGROW \| wxALL, 4)
323			controlButtonBox.Add(wxButton(self, ID_CLASSIFY_GENRANGE,
324			_("Generate Ranges")), 0, wxGROW \| wxALL, 4)
325	jonathan	372
326	jonathan	415	controlBox.Add(controlButtonBox, 0, wxGROW, 10)
327			topBox.Add(controlBox, 1, wxGROW, 10)
328
329			EVT_BUTTON(self, ID_CLASSIFY_ADD, self.OnAdd)
330			EVT_BUTTON(self, ID_CLASSIFY_GENRANGE, self.OnGenRange)
331			EVT_GRID_CELL_LEFT_DCLICK(self.classGrid, self.OnCellDClick)
332
333	jonathan	372	#
334			# Control buttons:
335			#
336			buttonBox = wxBoxSizer(wxHORIZONTAL)
337	jan	374	buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
338	jonathan	372	0, wxALL, 4)
339	jan	374	buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
340	jonathan	372	0, wxALL, 4)
341			topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL\|wxALIGN_BOTTOM, 10)
342
343			EVT_BUTTON(self, ID_CLASSIFY_OK, self.OnOK)
344			EVT_BUTTON(self, ID_CLASSIFY_CANCEL, self.OnCancel)
345
346			self.SetAutoLayout(true)
347			self.SetSizer(topBox)
348			topBox.Fit(self)
349			topBox.SetSizeHints(self)
350
351	jonathan	415	def __BuildClassification(self, prop):
352
353			clazz = Classification()
354			clazz.SetField(self.properties.GetStringSelection())
355
356			numRows = self.classGrid.GetNumberRows()
357
358			if numRows > 0:
359			table = self.classGrid.GetTable()
360	jonathan	441	clazz.SetDefaultGroup(table.GetClassGroup(0))
361	jonathan	415
362			for i in range(1, numRows):
363	jonathan	441	clazz.AddGroup(table.GetClassGroup(i))
364	jonathan	415
365			return clazz
366
367			def OnPropertySelect(self, event):
368			self.properties.SetClientData(
369			self.__cur_prop, self.__BuildClassification(self.__cur_prop))
370
371			self.__cur_prop = self.properties.GetSelection()
372			clazz = self.properties.GetClientData(self.__cur_prop)
373			table = self.classGrid.GetTable()
374
375			table.Reset(clazz, self.layer.ShapeType())
376
377			def OnOK(self, event):
378			"""Put the data from the table into a new Classification and hand
379			it to the layer.
380			"""
381
382			clazz = self.properties.GetClientData(self.__cur_prop)
383
384			#
385			# only build the classification if there wasn't one to
386			# to begin with or it has been modified
387			#
388			if clazz is None or self.classGrid.GetTable().IsModified():
389			clazz = self.__BuildClassification(self.__cur_prop)
390
391			clazz.SetLayer(self.layer)
392
393			self.layer.SetClassification(clazz)
394
395			self.EndModal(wxID_OK)
396
397			def OnCancel(self, event):
398			"""Do nothing. The layer's current classification stays the same."""
399			self.EndModal(wxID_CANCEL)
400
401
402			def OnAdd(self, event):
403			self.classGrid.GetTable().AddNewDataRow()
404			print "Classifier.OnAdd()"
405
406			def OnGenRange(self, event):
407			print "Classifier.OnGenRange()"
408
409			def OnCellDClick(self, event):
410			r = event.GetRow()
411			c = event.GetCol()
412			if c == COL_VISUAL:
413	jonathan	441	# XXX: getting the properties is only possible with non-Maps!!!
414			group = self.classGrid.GetTable().GetValueAsCustom(r, c, None)
415			prop = group.GetProperties()
416	jonathan	415	propDlg = SelectPropertiesDialog(NULL, prop, self.layer.ShapeType())
417			if propDlg.ShowModal() == wxID_OK:
418	jonathan	441	new_prop = propDlg.GetClassGroupProperties()
419	jonathan	415	prop.SetStroke(new_prop.GetStroke())
420			prop.SetStrokeWidth(new_prop.GetStrokeWidth())
421			prop.SetFill(new_prop.GetFill())
422	jonathan	430	self.classGrid.Refresh()
423	jonathan	415	propDlg.Destroy()
424
425
426			ID_SELPROP_OK = 4001
427			ID_SELPROP_CANCEL = 4002
428			ID_SELPROP_SPINCTRL = 4002
429	jonathan	430	ID_SELPROP_PREVIEW = 4003
430			ID_SELPROP_STROKECLR = 4004
431			ID_SELPROP_FILLCLR = 4005
432	jonathan	415
433			class SelectPropertiesDialog(wxDialog):
434
435			def __init__(self, parent, prop, shapeType):
436			wxDialog.__init__(self, parent, -1, _("Select Properties"),
437			style = wxRESIZE_BORDER)
438
439	jonathan	441	self.prop = ClassGroupProperties(prop)
440	jonathan	415
441	jonathan	430	topBox = wxBoxSizer(wxVERTICAL)
442	jonathan	415
443	jonathan	430	itemBox = wxBoxSizer(wxHORIZONTAL)
444
445			# preview box
446			previewBox = wxBoxSizer(wxVERTICAL)
447			previewBox.Add(wxStaticText(self, -1, _("Preview:")),
448			0, wxALIGN_LEFT \| wxALL, 4)
449			self.previewer = ClassDataPreviewer(None, self.prop, shapeType,
450			self, ID_SELPROP_PREVIEW, (40, 40))
451			previewBox.Add(self.previewer, 1, wxGROW, 15)
452
453			itemBox.Add(previewBox, 1, wxALIGN_LEFT \| wxALL \| wxGROW, 0)
454
455			# control box
456			ctrlBox = wxBoxSizer(wxVERTICAL)
457			ctrlBox.Add(
458			wxButton(self, ID_SELPROP_STROKECLR, "Change Stroke Color"),
459			0, wxALIGN_CENTER_HORIZONTAL \| wxALL \| wxGROW, 4)
460			EVT_BUTTON(self, ID_SELPROP_STROKECLR, self.OnChangeStrokeColor)
461
462			if shapeType != SHAPETYPE_ARC:
463			ctrlBox.Add(
464			wxButton(self, ID_SELPROP_FILLCLR, "Change Fill Color"),
465			0, wxALIGN_LEFT \| wxALL \| wxGROW, 4)
466			EVT_BUTTON(self, ID_SELPROP_FILLCLR, self.OnChangeFillColor)
467
468	jonathan	415	spinBox = wxBoxSizer(wxHORIZONTAL)
469			spinBox.Add(wxStaticText(self, -1, _("Stroke Width: ")),
470	jonathan	430	0, wxALIGN_LEFT \| wxALIGN_CENTER_VERTICAL \| wxALL, 4)
471	jonathan	415	self.spinCtrl = wxSpinCtrl(self, ID_SELPROP_SPINCTRL,
472			min=1, max=10,
473			value=str(prop.GetStrokeWidth()),
474			initial=prop.GetStrokeWidth())
475
476			EVT_SPINCTRL(self, ID_SELPROP_SPINCTRL, self.OnSpin)
477
478			spinBox.Add(self.spinCtrl, 0, wxALIGN_LEFT \| wxALL, 4)
479
480	jonathan	430	ctrlBox.Add(spinBox, 0, wxALIGN_RIGHT \| wxALL, 0)
481			itemBox.Add(ctrlBox, 0, wxALIGN_RIGHT \| wxALL \| wxGROW, 0)
482			topBox.Add(itemBox, 1, wxALIGN_LEFT \| wxALL \| wxGROW, 0)
483	jonathan	415
484
485			#
486			# Control buttons:
487			#
488			buttonBox = wxBoxSizer(wxHORIZONTAL)
489			buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
490			0, wxALL, 4)
491			buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
492			0, wxALL, 4)
493			topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL\|wxALIGN_BOTTOM, 10)
494
495			EVT_BUTTON(self, ID_SELPROP_OK, self.OnOK)
496			EVT_BUTTON(self, ID_SELPROP_CANCEL, self.OnCancel)
497
498			self.SetAutoLayout(true)
499			self.SetSizer(topBox)
500			topBox.Fit(self)
501			topBox.SetSizeHints(self)
502
503	jonathan	372	def OnOK(self, event):
504			self.EndModal(wxID_OK)
505
506			def OnCancel(self, event):
507			self.EndModal(wxID_CANCEL)
508
509	jonathan	415	def OnSpin(self, event):
510			self.prop.SetStrokeWidth(self.spinCtrl.GetValue())
511	jonathan	430	self.previewer.Refresh()
512	jonathan	392
513	jonathan	430	def __GetColor(self, cur):
514			dialog = wxColourDialog(self)
515			dialog.GetColourData().SetColour(Color2wxColour(cur))
516			ret = None
517			if dialog.ShowModal() == wxID_OK:
518			ret = wxColour2Color(dialog.GetColourData().GetColour())
519
520			dialog.Destroy()
521
522			return ret
523
524			def OnChangeStrokeColor(self, event):
525			clr = self.__GetColor(self.prop.GetStroke())
526			if clr is not None:
527			self.prop.SetStroke(clr)
528			self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer
529
530			def OnChangeFillColor(self, event):
531			clr = self.__GetColor(self.prop.GetFill())
532			if clr is not None:
533			self.prop.SetFill(clr)
534			self.previewer.Refresh() # XXX: work around, see ClassDataPreviewer
535
536	jonathan	441	def GetClassGroupProperties(self):
537	jonathan	415	return self.prop
538	jonathan	392
539
540	jonathan	430	class ClassDataPreviewer(wxWindow):
541	jonathan	415
542	jonathan	441	def __init__(self, rect, prop, shapeType,
543	jonathan	430	parent = None, id = -1, size = wxDefaultSize):
544			if parent is not None:
545			wxWindow.__init__(self, parent, id, size=size)
546			EVT_PAINT(self, self.OnPaint)
547	jonathan	415
548	jonathan	430	self.rect = rect
549	jonathan	441	self.prop = prop
550	jonathan	430	self.shapeType = shapeType
551
552			def OnPaint(self, event):
553			dc = wxPaintDC(self)
554
555			# XXX: this doesn't seem to be having an effect:
556			dc.DestroyClippingRegion()
557
558			self.Draw(dc, None)
559
560	jonathan	441	def Draw(self, dc, rect, prop = None, shapeType = None):
561	jonathan	430
562	jonathan	441	if prop is None: prop = self.prop
563	jonathan	430	if shapeType is None: shapeType = self.shapeType
564
565			if rect is None:
566			x = y = 0
567			w, h = self.GetClientSizeTuple()
568			else:
569			x = rect.GetX()
570			y = rect.GetY()
571			w = rect.GetWidth()
572			h = rect.GetHeight()
573
574	jonathan	441	stroke = prop.GetStroke()
575	jonathan	415	if stroke is Color.None:
576	jonathan	392	pen = wxTRANSPARENT_PEN
577			else:
578	jonathan	430	pen = wxPen(Color2wxColour(stroke),
579	jonathan	441	prop.GetStrokeWidth(),
580	jonathan	392	wxSOLID)
581
582	jonathan	441	stroke = prop.GetFill()
583	jonathan	415	if stroke is Color.None:
584	jonathan	392	brush = wxTRANSPARENT_BRUSH
585			else:
586	jonathan	430	brush = wxBrush(Color2wxColour(stroke), wxSOLID)
587	jonathan	392
588			dc.SetPen(pen)
589			dc.SetBrush(brush)
590
591	jonathan	415	if shapeType == SHAPETYPE_ARC:
592	jonathan	430	dc.DrawSpline([wxPoint(x, y + h),
593			wxPoint(x + w/2, y + h/4),
594			wxPoint(x + w/2, y + h/4*3),
595			wxPoint(x + w, y)])
596	jonathan	392
597	jonathan	415	elif shapeType == SHAPETYPE_POINT or \
598			shapeType == SHAPETYPE_POLYGON:
599
600	jonathan	430	dc.DrawCircle(x + w/2, y + h/2,
601	jonathan	441	(min(w, h) - prop.GetStrokeWidth())/2)
602	jonathan	392
603	jonathan	415	class ClassRenderer(wxPyGridCellRenderer):
604
605			def __init__(self, shapeType):
606			wxPyGridCellRenderer.__init__(self)
607	jonathan	430	self.previewer = ClassDataPreviewer(None, None, shapeType)
608	jonathan	415
609			def Draw(self, grid, attr, dc, rect, row, col, isSelected):
610			data = grid.GetTable().GetValueAsCustom(row, col, "")
611
612
613			dc.SetClippingRegion(rect.GetX(), rect.GetY(),
614			rect.GetWidth(), rect.GetHeight())
615			dc.SetPen(wxPen(wxLIGHT_GREY))
616			dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
617			dc.DrawRectangle(rect.GetX(), rect.GetY(),
618			rect.GetWidth(), rect.GetHeight())
619
620	jonathan	441	if not isinstance(data, ClassGroupMap):
621			self.previewer.Draw(dc, rect, data.GetProperties())
622	jonathan	415
623			if isSelected:
624			dc.SetPen(wxPen(wxColour(0 * 255, 0 * 255, 0 * 255),
625			4, wxSOLID))
626			dc.SetBrush(wxTRANSPARENT_BRUSH)
627			dc.DrawRectangle(rect.GetX(), rect.GetY(),
628			rect.GetWidth(), rect.GetHeight())
629
630	jonathan	392	dc.DestroyClippingRegion()
631
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision