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.Model.classification import Classification

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

class ClassTable(wxPyGridTableBase):

    def __init__(self, clinfo):
        wxPyGridTableBase.__init__(self)
        self.clinfo = copy.deepcopy(clinfo)

        self.tdata = []

        self.tdata.append([self.clinfo.DefaultData, 'DEFAULT'])

        for value, data in self.clinfo.points.items():
            self.tdata.append([data, value])

        for range in self.clinfo.ranges:
            self.tdata.append([range[2], '%s-%s' % range[0], range[1]])

        self.SetColLabelValue(1, _("Data Values"))
 
    def GetNumberRows(self):
        return len(self.tdata)

    def GetNumberCols(self):
        return 2

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

    def GetValue(self, row, col):
        return self.tdata[row][col]

    def SetValue(self, row, col, value):
        self.tdata[row][col] = value

    def GetValueAsCustom(self, row, col, typeName):
        return self.tdata[row][col]


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

        topBox = wxBoxSizer(wxVERTICAL)

        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()
        cur_hilight = 0
        for i in range(self.num_cols):
            type, name, len, decc = layer.table.field_info(i)
            if name == layer.classification.field:
                cur_hilight = i
            self.properties.Append(name)

        self.properties.SetSelection(cur_hilight)
        propertyBox.Add(self.properties, 1, wxGROW, 4)
        EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self.OnPropertySelect)

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

        #
        # Classification data table
        #

        self.classTable = wxGrid(self, ID_CLASS_TABLE, size=(300, 150))

        table = ClassTable(layer.classification)
        self.classTable.SetTable(table, true)
        self.classTable.EnableEditing(false)
        cr = ClassRenderer(layer.ShapeType())
        for i in range(self.classTable.GetNumberRows()):
            self.classTable.SetCellRenderer(i, 0, cr)

        topBox.Add(self.classTable, 1, 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_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 OnPropertySelect(self, event): pass
 
    def OnOK(self, event):
        self.EndModal(wxID_OK)

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


class ClassRenderer(wxPyGridCellRenderer):

    def __init__(self, shapeType):
        wxPyGridCellRenderer.__init__(self)
        self.shapeType = shapeType

    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
        value = grid.GetTable().GetValueAsCustom(row, col, "")
        # XXX: check if value is a dictionary
        stroke = value.GetStroke()
        if stroke is None:
            pen = wxTRANSPARENT_PEN
        else:
            pen = wxPen(wxColour(stroke.red * 255,
                                 stroke.green * 255,
                                 stroke.blue * 255),
                        value.GetStrokeWidth(),
                        wxSOLID)

        stroke = value.GetFill()
        if stroke is None:
            brush = wxTRANSPARENT_BRUSH
        else:
            brush = wxBrush(wxColour(stroke.red * 255,
                                     stroke.green * 255,
                                     stroke.blue * 255), wxSOLID)

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

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

        if self.shapeType == SHAPETYPE_ARC:
            dc.DrawSpline([wxPoint(rect.GetX(), rect.GetY() + rect.GetHeight()),
                           wxPoint(rect.GetX() + rect.GetWidth()/2, 
                                   rect.GetY() + rect.GetHeight()/4),
                           wxPoint(rect.GetX() + rect.GetWidth()/2, 
                                   rect.GetY() + rect.GetHeight()/4*3),
                           wxPoint(rect.GetX() + rect.GetWidth(), rect.GetY())])

        elif self.shapeType == SHAPETYPE_POINT or self.shapeType == SHAPETYPE_POLYGON:
            dc.DrawCircle(rect.GetX() + rect.GetWidth()/2,
                          rect.GetY() + rect.GetHeight()/2,
                          (min(rect.GetWidth(), rect.GetHeight())
                           - value.GetStrokeWidth())/2)

        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
19	jonathan	392	from Thuban.Model.classification import Classification
20
21			from Thuban.Model.layer import SHAPETYPE_ARC, SHAPETYPE_POLYGON, SHAPETYPE_POINT
22
23	jonathan	372	ID_PROPERTY_SELECT = 4010
24			ID_CLASS_TABLE = 40011
25
26			ID_CLASSIFY_OK = 4001
27			ID_CLASSIFY_CANCEL = 4002
28
29	jonathan	376	class ClassTable(wxPyGridTableBase):
30
31			def __init__(self, clinfo):
32			wxPyGridTableBase.__init__(self)
33			self.clinfo = copy.deepcopy(clinfo)
34
35			self.tdata = []
36
37	jonathan	392	self.tdata.append([self.clinfo.DefaultData, 'DEFAULT'])
38
39	jonathan	376	for value, data in self.clinfo.points.items():
40			self.tdata.append([data, value])
41
42			for range in self.clinfo.ranges:
43			self.tdata.append([range[2], '%s-%s' % range[0], range[1]])
44
45	jonathan	379	self.SetColLabelValue(1, _("Data Values"))
46	jonathan	376
47			def GetNumberRows(self):
48			return len(self.tdata)
49
50			def GetNumberCols(self):
51			return 2
52
53			def IsEmptyCell(self, row, col):
54			return false
55
56			def GetValue(self, row, col):
57			return self.tdata[row][col]
58
59			def SetValue(self, row, col, value):
60	jonathan	392	self.tdata[row][col] = value
61	jonathan	376
62	jonathan	392	def GetValueAsCustom(self, row, col, typeName):
63			return self.tdata[row][col]
64	jonathan	376
65	jonathan	392
66	jonathan	372	class Classifier(wxDialog):
67
68			def __init__(self, parent, layer):
69	jan	374	wxDialog.__init__(self, parent, -1, _("Classify"),
70	jonathan	372	style = wxRESIZE_BORDER)
71
72			topBox = wxBoxSizer(wxVERTICAL)
73
74			propertyBox = wxBoxSizer(wxHORIZONTAL)
75	jan	374	propertyBox.Add(wxStaticText(self, -1, _("Property")),
76	jonathan	372	0, wxALIGN_CENTER \| wxALL, 4)
77
78			self.properties = wxComboBox(self, ID_PROPERTY_SELECT, "",
79			style = wxCB_READONLY)
80
81			self.num_cols = layer.table.field_count()
82	jonathan	376	cur_hilight = 0
83	jonathan	372	for i in range(self.num_cols):
84			type, name, len, decc = layer.table.field_info(i)
85	jonathan	376	if name == layer.classification.field:
86			cur_hilight = i
87	jonathan	372	self.properties.Append(name)
88
89	jonathan	376	self.properties.SetSelection(cur_hilight)
90	jonathan	392	propertyBox.Add(self.properties, 1, wxGROW, 4)
91	jonathan	372	EVT_COMBOBOX(self, ID_PROPERTY_SELECT, self.OnPropertySelect)
92
93	jonathan	376	topBox.Add(propertyBox, 0, wxGROW, 4)
94	jonathan	372
95			#
96			# Classification data table
97			#
98
99	jonathan	376	self.classTable = wxGrid(self, ID_CLASS_TABLE, size=(300, 150))
100
101			table = ClassTable(layer.classification)
102	jonathan	372	self.classTable.SetTable(table, true)
103	jonathan	392	self.classTable.EnableEditing(false)
104			cr = ClassRenderer(layer.ShapeType())
105			for i in range(self.classTable.GetNumberRows()):
106			self.classTable.SetCellRenderer(i, 0, cr)
107	jonathan	376
108	jonathan	392	topBox.Add(self.classTable, 1, wxGROW, 0)
109	jonathan	372
110			#
111			# Control buttons:
112			#
113			buttonBox = wxBoxSizer(wxHORIZONTAL)
114	jan	374	buttonBox.Add(wxButton(self, ID_CLASSIFY_OK, _("OK")),
115	jonathan	372	0, wxALL, 4)
116	jan	374	buttonBox.Add(wxButton(self, ID_CLASSIFY_CANCEL, _("Cancel")),
117	jonathan	372	0, wxALL, 4)
118			topBox.Add(buttonBox, 0, wxALIGN_CENTER_HORIZONTAL\|wxALIGN_BOTTOM, 10)
119
120			EVT_BUTTON(self, ID_CLASSIFY_OK, self.OnOK)
121			EVT_BUTTON(self, ID_CLASSIFY_CANCEL, self.OnCancel)
122
123			self.SetAutoLayout(true)
124			self.SetSizer(topBox)
125			topBox.Fit(self)
126			topBox.SetSizeHints(self)
127
128			def OnPropertySelect(self, event): pass
129
130			def OnOK(self, event):
131			self.EndModal(wxID_OK)
132
133			def OnCancel(self, event):
134			self.EndModal(wxID_CANCEL)
135
136	jonathan	392
137			class ClassRenderer(wxPyGridCellRenderer):
138
139			def __init__(self, shapeType):
140			wxPyGridCellRenderer.__init__(self)
141			self.shapeType = shapeType
142
143			def Draw(self, grid, attr, dc, rect, row, col, isSelected):
144			value = grid.GetTable().GetValueAsCustom(row, col, "")
145			# XXX: check if value is a dictionary
146			stroke = value.GetStroke()
147			if stroke is None:
148			pen = wxTRANSPARENT_PEN
149			else:
150			pen = wxPen(wxColour(stroke.red * 255,
151			stroke.green * 255,
152			stroke.blue * 255),
153			value.GetStrokeWidth(),
154			wxSOLID)
155
156			stroke = value.GetFill()
157			if stroke is None:
158			brush = wxTRANSPARENT_BRUSH
159			else:
160			brush = wxBrush(wxColour(stroke.red * 255,
161			stroke.green * 255,
162			stroke.blue * 255), wxSOLID)
163
164			dc.SetClippingRegion(rect.GetX(), rect.GetY(),
165			rect.GetWidth(), rect.GetHeight())
166			dc.SetPen(wxPen(wxLIGHT_GREY))
167			dc.SetBrush(wxBrush(wxLIGHT_GREY, wxSOLID))
168			dc.DrawRectangle(rect.GetX(), rect.GetY(),
169			rect.GetWidth(), rect.GetHeight())
170
171			dc.SetPen(pen)
172			dc.SetBrush(brush)
173
174			if self.shapeType == SHAPETYPE_ARC:
175			dc.DrawSpline([wxPoint(rect.GetX(), rect.GetY() + rect.GetHeight()),
176			wxPoint(rect.GetX() + rect.GetWidth()/2,
177			rect.GetY() + rect.GetHeight()/4),
178			wxPoint(rect.GetX() + rect.GetWidth()/2,
179			rect.GetY() + rect.GetHeight()/4*3),
180			wxPoint(rect.GetX() + rect.GetWidth(), rect.GetY())])
181
182			elif self.shapeType == SHAPETYPE_POINT or self.shapeType == SHAPETYPE_POLYGON:
183			dc.DrawCircle(rect.GetX() + rect.GetWidth()/2,
184			rect.GetY() + rect.GetHeight()/2,
185			(min(rect.GetWidth(), rect.GetHeight())
186			- value.GetStrokeWidth())/2)
187
188			dc.DestroyClippingRegion()
189
190
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision