]> git.saurik.com Git - wxWidgets.git/blob - wxPython/demo/GridCustEditor.py
doc tweaks, typo fixed, etc.
[wxWidgets.git] / wxPython / demo / GridCustEditor.py
1 # 11/6/2003 - Jeff Grimmett (grimmtooth@softhome.net)
2 #
3 # Modified for wx namespace
4 #
5
6 import string
7
8 import wx
9 import wx.grid as gridlib
10
11 #---------------------------------------------------------------------------
12 class MyCellEditor(gridlib.PyGridCellEditor):
13 """
14 This is a sample GridCellEditor that shows you how to make your own custom
15 grid editors. All the methods that can be overridden are show here. The
16 ones that must be overridden are marked with "*Must Override*" in the
17 docstring.
18
19 Notice that in order to call the base class version of these special
20 methods we use the method name preceded by "base_". This is because these
21 methods are "virtual" in C++ so if we try to call wxGridCellEditor.Create
22 for example, then when the wxPython extension module tries to call
23 ptr->Create(...) then it actually calls the derived class version which
24 looks up the method in this class and calls it, causing a recursion loop.
25 If you don't understand any of this, don't worry, just call the "base_"
26 version instead.
27 """
28 def __init__(self, log):
29 self.log = log
30 self.log.write("MyCellEditor ctor\n")
31 gridlib.PyGridCellEditor.__init__(self)
32
33
34 def Create(self, parent, id, evtHandler):
35 """
36 Called to create the control, which must derive from wx.Control.
37 *Must Override*
38 """
39 self.log.write("MyCellEditor: Create\n")
40 self._tc = wx.TextCtrl(parent, id, "")
41 self._tc.SetInsertionPoint(0)
42 self.SetControl(self._tc)
43
44 if evtHandler:
45 self._tc.PushEventHandler(evtHandler)
46
47
48 def SetSize(self, rect):
49 """
50 Called to position/size the edit control within the cell rectangle.
51 If you don't fill the cell (the rect) then be sure to override
52 PaintBackground and do something meaningful there.
53 """
54 self.log.write("MyCellEditor: SetSize %s\n" % rect)
55 self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
56 wx.SIZE_ALLOW_MINUS_ONE)
57
58
59 def Show(self, show, attr):
60 """
61 Show or hide the edit control. You can use the attr (if not None)
62 to set colours or fonts for the control.
63 """
64 self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr))
65 self.base_Show(show, attr)
66
67
68 def PaintBackground(self, rect, attr):
69 """
70 Draws the part of the cell not occupied by the edit control. The
71 base class version just fills it with background colour from the
72 attribute. In this class the edit control fills the whole cell so
73 don't do anything at all in order to reduce flicker.
74 """
75 self.log.write("MyCellEditor: PaintBackground\n")
76
77
78 def BeginEdit(self, row, col, grid):
79 """
80 Fetch the value from the table and prepare the edit control
81 to begin editing. Set the focus to the edit control.
82 *Must Override*
83 """
84 self.log.write("MyCellEditor: BeginEdit (%d,%d)\n" % (row, col))
85 self.startValue = grid.GetTable().GetValue(row, col)
86 self._tc.SetValue(self.startValue)
87 self._tc.SetInsertionPointEnd()
88 self._tc.SetFocus()
89
90 # For this example, select the text
91 self._tc.SetSelection(0, self._tc.GetLastPosition())
92
93
94 def EndEdit(self, row, col, grid):
95 """
96 Complete the editing of the current cell. Returns True if the value
97 has changed. If necessary, the control may be destroyed.
98 *Must Override*
99 """
100 self.log.write("MyCellEditor: EndEdit (%d,%d)\n" % (row, col))
101 changed = False
102
103 val = self._tc.GetValue()
104
105 if val != self.startValue:
106 changed = True
107 grid.GetTable().SetValue(row, col, val) # update the table
108
109 self.startValue = ''
110 self._tc.SetValue('')
111 return changed
112
113
114 def Reset(self):
115 """
116 Reset the value in the control back to its starting value.
117 *Must Override*
118 """
119 self.log.write("MyCellEditor: Reset\n")
120 self._tc.SetValue(self.startValue)
121 self._tc.SetInsertionPointEnd()
122
123
124 def IsAcceptedKey(self, evt):
125 """
126 Return True to allow the given key to start editing: the base class
127 version only checks that the event has no modifiers. F2 is special
128 and will always start the editor.
129 """
130 self.log.write("MyCellEditor: IsAcceptedKey: %d\n" % (evt.GetKeyCode()))
131
132 ## Oops, there's a bug here, we'll have to do it ourself..
133 ##return self.base_IsAcceptedKey(evt)
134
135 return (not (evt.ControlDown() or evt.AltDown()) and
136 evt.GetKeyCode() != wx.WXK_SHIFT)
137
138
139 def StartingKey(self, evt):
140 """
141 If the editor is enabled by pressing keys on the grid, this will be
142 called to let the editor do something about that first key if desired.
143 """
144 self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode())
145 key = evt.GetKeyCode()
146 ch = None
147 if key in [ wx.WXK_NUMPAD0, wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3,
148 wx.WXK_NUMPAD4, wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7,
149 wx.WXK_NUMPAD8, wx.WXK_NUMPAD9
150 ]:
151
152 ch = ch = chr(ord('0') + key - wx.WXK_NUMPAD0)
153
154 elif key < 256 and key >= 0 and chr(key) in string.printable:
155 ch = chr(key)
156 if not evt.ShiftDown():
157 ch = ch.lower()
158
159 if ch is not None:
160 # For this example, replace the text. Normally we would append it.
161 #self._tc.AppendText(ch)
162 self._tc.SetValue(ch)
163 self._tc.SetInsertionPointEnd()
164 else:
165 evt.Skip()
166
167
168 def StartingClick(self):
169 """
170 If the editor is enabled by clicking on the cell, this method will be
171 called to allow the editor to simulate the click on the control if
172 needed.
173 """
174 self.log.write("MyCellEditor: StartingClick\n")
175
176
177 def Destroy(self):
178 """final cleanup"""
179 self.log.write("MyCellEditor: Destroy\n")
180 self.base_Destroy()
181
182
183 def Clone(self):
184 """
185 Create a new object which is the copy of this one
186 *Must Override*
187 """
188 self.log.write("MyCellEditor: Clone\n")
189 return MyCellEditor(self.log)
190
191
192 #---------------------------------------------------------------------------
193 class GridEditorTest(gridlib.Grid):
194 def __init__(self, parent, log):
195 gridlib.Grid.__init__(self, parent, -1)
196 self.log = log
197
198 self.CreateGrid(10, 3)
199
200 # Somebody changed the grid so the type registry takes precedence
201 # over the default attribute set for editors and renderers, so we
202 # have to set null handlers for the type registry before the
203 # default editor will get used otherwise...
204 #self.RegisterDataType(wxGRID_VALUE_STRING, None, None)
205 #self.SetDefaultEditor(MyCellEditor(self.log))
206
207 # Or we could just do it like this:
208 #self.RegisterDataType(wx.GRID_VALUE_STRING,
209 # wx.GridCellStringRenderer(),
210 # MyCellEditor(self.log))
211 # )
212
213 # but for this example, we'll just set the custom editor on one cell
214 self.SetCellEditor(1, 0, MyCellEditor(self.log))
215 self.SetCellValue(1, 0, "Try to edit this box")
216
217 # and on a column
218 attr = gridlib.GridCellAttr()
219 attr.SetEditor(MyCellEditor(self.log))
220 self.SetColAttr(2, attr)
221 self.SetCellValue(1, 2, "or any in this column")
222
223 self.SetColSize(0, 150)
224 self.SetColSize(1, 150)
225 self.SetColSize(2, 150)
226
227
228 #---------------------------------------------------------------------------
229
230 class TestFrame(wx.Frame):
231 def __init__(self, parent, log):
232 wx.Frame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
233 size=(640,480))
234 grid = GridEditorTest(self, log)
235
236 #---------------------------------------------------------------------------
237
238 if __name__ == '__main__':
239 import sys
240 app = wx.PySimpleApp()
241 frame = TestFrame(None, sys.stdout)
242 frame.Show(True)
243 app.MainLoop()
244
245