-from wxPython.wx import *
-from wxPython.grid import *
+import string
+
+import wx
+import wx.grid as gridlib
#---------------------------------------------------------------------------
-class MyCellEditor(wxPyGridCellEditor):
+class MyCellEditor(gridlib.PyGridCellEditor):
"""
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
+ grid editors. All the methods that can be overridden are shown here. The
ones that must be overridden are marked with "*Must Override*" in the
docstring.
-
- 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 wxGridCellEditor.Create
- for example, then when the wxPython 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.
"""
def __init__(self, log):
self.log = log
self.log.write("MyCellEditor ctor\n")
- wxPyGridCellEditor.__init__(self)
+ gridlib.PyGridCellEditor.__init__(self)
def Create(self, parent, id, evtHandler):
"""
- Called to create the control, which must derive from wxControl.
+ Called to create the control, which must derive from wx.Control.
*Must Override*
"""
self.log.write("MyCellEditor: Create\n")
- self._tc = wxTextCtrl(parent, id, "")
+ self._tc = wx.TextCtrl(parent, id, "")
self._tc.SetInsertionPoint(0)
self.SetControl(self._tc)
+
if evtHandler:
self._tc.PushEventHandler(evtHandler)
"""
self.log.write("MyCellEditor: SetSize %s\n" % rect)
self._tc.SetDimensions(rect.x, rect.y, rect.width+2, rect.height+2,
- wxSIZE_ALLOW_MINUS_ONE)
+ wx.SIZE_ALLOW_MINUS_ONE)
def Show(self, show, attr):
to set colours or fonts for the control.
"""
self.log.write("MyCellEditor: Show(self, %s, %s)\n" % (show, attr))
- self.base_Show(show, attr)
+ super(MyCellEditor, self).Show(show, attr)
def PaintBackground(self, rect, attr):
def EndEdit(self, row, col, grid):
"""
- Complete the editing of the current cell. Returns true if the value
+ 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
+ changed = False
val = self._tc.GetValue()
+
if val != self.startValue:
- changed = true
+ changed = True
grid.GetTable().SetValue(row, col, val) # update the table
self.startValue = ''
def IsAcceptedKey(self, evt):
"""
- Return TRUE to allow the given key to start editing: the base class
+ 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)
+ ## We can ask the base class to do it
+ #return super(MyCellEditor, self).IsAcceptedKey(evt)
+ # or do it ourselves
return (not (evt.ControlDown() or evt.AltDown()) and
- evt.GetKeyCode() != WXK_SHIFT)
+ evt.GetKeyCode() != wx.WXK_SHIFT)
def StartingKey(self, evt):
self.log.write("MyCellEditor: StartingKey %d\n" % evt.GetKeyCode())
key = evt.GetKeyCode()
ch = None
- if key in [WXK_NUMPAD0, WXK_NUMPAD1, WXK_NUMPAD2, WXK_NUMPAD3, WXK_NUMPAD4,
- WXK_NUMPAD5, WXK_NUMPAD6, WXK_NUMPAD7, WXK_NUMPAD8, WXK_NUMPAD9]:
- ch = ch = chr(ord('0') + key - WXK_NUMPAD0)
+ 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 = string.lower(ch)
if ch is not None:
# For this example, replace the text. Normally we would append it.
#self._tc.AppendText(ch)
self._tc.SetValue(ch)
+ self._tc.SetInsertionPointEnd()
else:
evt.Skip()
def Destroy(self):
"""final cleanup"""
self.log.write("MyCellEditor: Destroy\n")
- self.base_Destroy()
+ super(MyCellEditor, self).Destroy()
def Clone(self):
#---------------------------------------------------------------------------
-class GridEditorTest(wxGrid):
+class GridEditorTest(gridlib.Grid):
def __init__(self, parent, log):
- wxGrid.__init__(self, parent, -1)
+ gridlib.Grid.__init__(self, parent, -1)
self.log = log
self.CreateGrid(10, 3)
#self.SetDefaultEditor(MyCellEditor(self.log))
# Or we could just do it like this:
- #self.RegisterDataType(wxGRID_VALUE_STRING,
- # wxGridCellStringRenderer(),
+ #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, "Try to edit this box")
# and on a column
- attr = wxGridCellAttr()
+ attr = gridlib.GridCellAttr()
attr.SetEditor(MyCellEditor(self.log))
self.SetColAttr(2, attr)
self.SetCellValue(1, 2, "or any in this column")
#---------------------------------------------------------------------------
-class TestFrame(wxFrame):
+class TestFrame(wx.Frame):
def __init__(self, parent, log):
- wxFrame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
+ wx.Frame.__init__(self, parent, -1, "Custom Grid Cell Editor Test",
size=(640,480))
grid = GridEditorTest(self, log)
if __name__ == '__main__':
import sys
- app = wxPySimpleApp()
+ app = wx.PySimpleApp()
frame = TestFrame(None, sys.stdout)
- frame.Show(true)
+ frame.Show(True)
app.MainLoop()
projects / wxWidgets.git / blobdiff