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