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