== Introduction == This is a second sample for `GridCellChoiceEditor` use. It is similar to the `GridCustEditor.py` example provided in the demo. == Code Sample == {{{ #!python import wx import wx.grid import string #--------------------------------------------------------------------------- class MyCellEditor(wx.grid.PyGridCellEditor): #class MyCellEditor(wx.grid.GridCellFloatEditor): """ This is a sample GridCellEditor that shows you how to make your own custom grid editors. All the methods that can be overridden are show here. The ones that must be overridden are marked with "*Must Override*" in the docstring. The sample custom editor is a choice editor. Notice that in order to call the base class version of these special methods we use the method name preceded by "base_". This is because these methods are "virtual" in C++ so if we try to call wx.grid.GridCellEditor. Create for example, then when the wx.Python extension module tries to call ptr->Create(...) then it actually calls the derived class version which looks up the method in this class and calls it, causing a recursion loop. If you don't understand any of this, don't worry, just call the "base_" version instead. NB: It comes from GridCustEditor.py available in the demo. """ def __init__(self, log): self.log = log self.log.write("MyCellEditor ctor\n") wx.grid.PyGridCellEditor.__init__(self) def Create(self, parent, id, evtHandler): """ Called to create the control, which must derive from wxControl. *Must Override* """ self.log.write("MyCellEditor: Create\n") sampleList = ['zero', 'one', 'two', 'three', 'four', 'five','six', 'seven', 'eight'] self._tc = wx.Choice(parent, id, (100, 50), choices = sampleList) self.SetControl(self._tc) if evtHandler: self._tc.PushEventHandler(evtHandler) def SetSize(self, rect): """ Called to position/size the edit control within the cell rectangle. If you don't fill the cell (the rect) then be sure to override PaintBackground and do something meaningful there. """ self.log.write("MyCellEditor: SetSize %s\n" % rect) self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2, wx.SIZE_ALLOW_MINUS_ONE) def Show(self, show, attr): """ Show or hide the edit control. You can use the attr (if not None) to set colours or fonts for the control. """ self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr)) self.base_Show(show, attr) def PaintBackground(self, rect, attr): """ Draws the part of the cell not occupied by the edit control. The base class version just fills it with background colour from the attribute. In this class the edit control fills the whole cell so don't do anything at all in order to reduce flicker. """ self.log.write("MyCellEditor: PaintBackground\n") def BeginEdit(self, row, col, grid): """ Fetch the value from the table and prepare the edit control to begin editing. Set the focus to the edit control. *Must Override* """ self.log.write("MyCellEditor: BeginEdit (%d,%d)\n" % (row, col)) self.startValue = grid.GetTable().GetValue(row, col) self._tc.SetStringSelection(self.startValue) self._tc.SetFocus() def EndEdit(self, row, col, grid): """ Complete the editing of the current cell. Returns True if the value has changed. If necessary, the control may be destroyed. *Must Override* """ self.log.write("MyCellEditor: EndEdit (%d,%d)\n" % (row, col)) changed = False val = self._tc.GetStringSelection() if val != self.startValue: changed = True grid.GetTable().SetValue(row, col, val) # update the table self.startValue = 'zero' self._tc.SetStringSelection('zero') return changed def Reset(self): """ Reset the value in the control back to its starting value. *Must Override* """ self.log.write("MyCellEditor: Reset\n") self._tc.SetStringSelection(self.startValue) #self._tc.SetInsertionPointEnd() def IsAcceptedKey(self, evt): """ Return True to allow the given key to start editing: the base class version only checks that the event has no modifiers. F2 is special and will always start the editor. """ self.log.write("MyCellEditor: IsAcceptedKey: %d\n" % (evt.GetKeyCode())) ## Oops, there's a bug here, we'll have to do it ourself.. ##return self.base_IsAcceptedKey(evt) return (not (evt.ControlDown() or evt.AltDown()) and evt.GetKeyCode() != wx.WXK_SHIFT) def StartingKey(self, evt): """ If the editor is enabled by pressing keys on the grid, this will be called to let the editor do something about that first key if desired. """ self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode()) key = evt.GetKeyCode() ch = None if key in [wx.WXK_NUMPAD0, wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3, wx.WXK_NUMPAD4, wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7, wx.WXK_NUMPAD8, wx.WXK_NUMPAD9]: ch = ch = chr(ord('0') + key - wx.WXK_NUMPAD0) elif key < 256 and key >= 0 and chr(key) in string.printable: ch = chr(key) if not evt.ShiftDown(): ch = ch.lower() if ch is not None: self._tc.SetStringSelection(ch) else: evt.Skip() def StartingClick(self): """ If the editor is enabled by clicking on the cell, this method will be called to allow the editor to simulate the click on the control if needed. """ self.log.write("MyCellEditor: StartingClick\n") def Destroy(self): """final cleanup""" self.log.write("MyCellEditor: Destroy\n") self.base_Destroy() def Clone(self): """ Create a new object which is the copy of this one *Must Override* """ self.log.write("MyCellEditor: Clone\n") return MyCellEditor(self.log) #--------------------------------------------------------------------------- class GridEditorTest(wx.grid.Grid): def __init__(self, parent, log): wx.grid.Grid.__init__(self, parent, -1) self.log = log self.CreateGrid(10, 3) # Somebody changed the grid so the type registry takes precedence # over the default attribute set for editors and renderers, so we # have to set null handlers for the type registry before the # default editor will get used otherwise... #self.RegisterDataType(wx.GRID_VALUE_STRING, None, None) #self.SetDefaultEditor(MyCellEditor(self.log)) # Or we could just do it like this: #self.RegisterDataType(wx.GRID_VALUE_STRING, # wx.GridCellStringRenderer(), # MyCellEditor(self.log)) # but for this example, we'll just set the custom editor on one cell self.SetCellEditor(1, 0, MyCellEditor(self.log)) self.SetCellValue(1, 0, "11") # and on a column attr = wx.grid.GridCellAttr() attr.SetEditor(MyCellEditor(self.log)) self.SetColAttr(2, attr) self.SetCellValue(1, 2, "two") self.SetColSize(0, 150) self.SetColSize(1, 150) self.SetColSize(2, 75) #--------------------------------------------------------------------------- class TestFrame(wx.Frame): def __init__(self, parent, log): wx.Frame.__init__(self, parent, -1, "Custom Grid Cell Editor Test", size=(640,480)) grid = GridEditorTest(self, log) #--------------------------------------------------------------------------- if __name__ == '__main__': import sys app = wx.App(False) frame = TestFrame(None, sys.stdout) frame.Show(True) app.MainLoop() }}} === Comments === If you want to use it, it's probably a good idea to pick out the `MyCellEditor` class, and to use it as in the `__init__` method of `GridEditorTest` === Edits === I've found that on Linux the Choice box just doesn't work. Seems that when you click on the cell and start editing it, you have to click on it again to show the wxChoice. The evtHandler passes that up the event chain and calls EndEdit, before it even shows the list of choices! Hence no changes. The solution to this is to modify the create function to look like this {{{ #!python def Create(self, parent, id, evtHandler): """ Called to create the control, which must derive from wxControl. *Must Override* """ self.log.write("MyCellEditor: Create\n") sampleList = ['zero', 'one', 'two', 'three', 'four', 'five','six', 'seven', 'eight'] self._tc = wx.Choice(parent, id, (100, 50), choices = sampleList) self.SetControl(self._tc) if evtHandler: self._tc.PushEventHandler(evtHandler) evtHandler.SetEvtHandlerEnabled(False) # Add this line }}} Turns out you HAVE to have the evtHandler in there, otherwise on close it SegFaults, but you just don't want it to do anything. Also on my system setting the extra window style WS_EX_BLOCK_EVENTS had no affect.