wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/GridSimple.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python
+
+import wx
+import wx.grid as gridlib
+#import wx.lib.mixins.grid as mixins
+
+#---------------------------------------------------------------------------
+
+class SimpleGrid(gridlib.Grid): ##, mixins.GridAutoEditMixin):
+    def __init__(self, parent, log):
+        gridlib.Grid.__init__(self, parent, -1)
+        ##mixins.GridAutoEditMixin.__init__(self)
+        self.log = log
+        self.moveTo = None
+
+        self.Bind(wx.EVT_IDLE, self.OnIdle)
+
+        self.CreateGrid(25, 25)#, gridlib.Grid.SelectRows)
+        ##self.EnableEditing(False)
+
+        # simple cell formatting
+        self.SetColSize(3, 200)
+        self.SetRowSize(4, 45)
+        self.SetCellValue(0, 0, "First cell")
+        self.SetCellValue(1, 1, "Another cell")
+        self.SetCellValue(2, 2, "Yet another cell")
+        self.SetCellValue(3, 3, "This cell is read-only")
+        self.SetCellFont(0, 0, wx.Font(12, wx.FONTFAMILY_ROMAN, wx.FONTSTYLE_ITALIC, wx.FONTWEIGHT_NORMAL))
+        self.SetCellTextColour(1, 1, wx.RED)
+        self.SetCellBackgroundColour(2, 2, wx.CYAN)
+        self.SetReadOnly(3, 3, True)
+
+        self.SetCellEditor(5, 0, gridlib.GridCellNumberEditor(1,1000))
+        self.SetCellValue(5, 0, "123")
+        self.SetCellEditor(6, 0, gridlib.GridCellFloatEditor())
+        self.SetCellValue(6, 0, "123.34")
+        self.SetCellEditor(7, 0, gridlib.GridCellNumberEditor())
+
+        self.SetCellValue(6, 3, "You can veto editing this cell")
+
+        #self.SetRowLabelSize(0)
+        #self.SetColLabelSize(0)
+
+        # attribute objects let you keep a set of formatting values
+        # in one spot, and reuse them if needed
+        attr = gridlib.GridCellAttr()
+        attr.SetTextColour(wx.BLACK)
+        attr.SetBackgroundColour(wx.RED)
+        attr.SetFont(wx.Font(10, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD))
+
+        # you can set cell attributes for the whole row (or column)
+        self.SetRowAttr(5, attr)
+
+        self.SetColLabelValue(0, "Custom")
+        self.SetColLabelValue(1, "column")
+        self.SetColLabelValue(2, "labels")
+
+        self.SetColLabelAlignment(wx.ALIGN_LEFT, wx.ALIGN_BOTTOM)
+
+        #self.SetDefaultCellOverflow(False)
+        #r = gridlib.GridCellAutoWrapStringRenderer()
+        #self.SetCellRenderer(9, 1, r)
+
+        # overflow cells
+        self.SetCellValue( 9, 1, "This default cell will overflow into neighboring cells, but not if you turn overflow off.");
+        self.SetCellSize(11, 1, 3, 3);
+        self.SetCellAlignment(11, 1, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE);
+        self.SetCellValue(11, 1, "This cell is set to span 3 rows and 3 columns");
+
+
+        editor = gridlib.GridCellTextEditor()
+        editor.SetParameters('10')
+        self.SetCellEditor(0, 4, editor)
+        self.SetCellValue(0, 4, "Limited text")
+
+        renderer = gridlib.GridCellAutoWrapStringRenderer()
+        self.SetCellRenderer(15,0, renderer)
+        self.SetCellValue(15,0, "The text in this cell will be rendered with word-wrapping")
+
+
+        # test all the events
+        self.Bind(gridlib.EVT_GRID_CELL_LEFT_CLICK, self.OnCellLeftClick)
+        self.Bind(gridlib.EVT_GRID_CELL_RIGHT_CLICK, self.OnCellRightClick)
+        self.Bind(gridlib.EVT_GRID_CELL_LEFT_DCLICK, self.OnCellLeftDClick)
+        self.Bind(gridlib.EVT_GRID_CELL_RIGHT_DCLICK, self.OnCellRightDClick)
+
+        self.Bind(gridlib.EVT_GRID_LABEL_LEFT_CLICK, self.OnLabelLeftClick)
+        self.Bind(gridlib.EVT_GRID_LABEL_RIGHT_CLICK, self.OnLabelRightClick)
+        self.Bind(gridlib.EVT_GRID_LABEL_LEFT_DCLICK, self.OnLabelLeftDClick)
+        self.Bind(gridlib.EVT_GRID_LABEL_RIGHT_DCLICK, self.OnLabelRightDClick)
+
+        self.Bind(gridlib.EVT_GRID_COL_SORT, self.OnGridColSort)
+
+        self.Bind(gridlib.EVT_GRID_ROW_SIZE, self.OnRowSize)
+        self.Bind(gridlib.EVT_GRID_COL_SIZE, self.OnColSize)
+
+        self.Bind(gridlib.EVT_GRID_RANGE_SELECT, self.OnRangeSelect)
+        self.Bind(gridlib.EVT_GRID_CELL_CHANGED, self.OnCellChange)
+        self.Bind(gridlib.EVT_GRID_SELECT_CELL, self.OnSelectCell)
+
+        self.Bind(gridlib.EVT_GRID_EDITOR_SHOWN, self.OnEditorShown)
+        self.Bind(gridlib.EVT_GRID_EDITOR_HIDDEN, self.OnEditorHidden)
+        self.Bind(gridlib.EVT_GRID_EDITOR_CREATED, self.OnEditorCreated)
+
+
+    def OnCellLeftClick(self, evt):
+        self.log.write("OnCellLeftClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnCellRightClick(self, evt):
+        self.log.write("OnCellRightClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnCellLeftDClick(self, evt):
+        self.log.write("OnCellLeftDClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnCellRightDClick(self, evt):
+        self.log.write("OnCellRightDClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnLabelLeftClick(self, evt):
+        self.log.write("OnLabelLeftClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnLabelRightClick(self, evt):
+        self.log.write("OnLabelRightClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnLabelLeftDClick(self, evt):
+        self.log.write("OnLabelLeftDClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnLabelRightDClick(self, evt):
+        self.log.write("OnLabelRightDClick: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnGridColSort(self, evt):
+        self.log.write("OnGridColSort: %s %s" % (evt.GetCol(), self.GetSortingColumn()))
+        self.SetSortingColumn(evt.GetCol())
+
+    def OnRowSize(self, evt):
+        self.log.write("OnRowSize: row %d, %s\n" %
+                       (evt.GetRowOrCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnColSize(self, evt):
+        self.log.write("OnColSize: col %d, %s\n" %
+                       (evt.GetRowOrCol(), evt.GetPosition()))
+        evt.Skip()
+
+    def OnRangeSelect(self, evt):
+        if evt.Selecting():
+            msg = 'Selected'
+        else:
+            msg = 'Deselected'
+        self.log.write("OnRangeSelect: %s  top-left %s, bottom-right %s\n" %
+                           (msg, evt.GetTopLeftCoords(), evt.GetBottomRightCoords()))
+        evt.Skip()
+
+
+    def OnCellChange(self, evt):
+        self.log.write("OnCellChange: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+
+        # Show how to stay in a cell that has bad data.  We can't just
+        # call SetGridCursor here since we are nested inside one so it
+        # won't have any effect.  Instead, set coordinates to move to in
+        # idle time.
+        value = self.GetCellValue(evt.GetRow(), evt.GetCol())
+
+        if value == 'no good':
+            self.moveTo = evt.GetRow(), evt.GetCol()
+
+
+    def OnIdle(self, evt):
+        if self.moveTo is not None:
+            self.SetGridCursor(self.moveTo[0], self.moveTo[1])
+            self.moveTo = None
+
+        evt.Skip()
+
+
+    def OnSelectCell(self, evt):
+        if evt.Selecting():
+            msg = 'Selected'
+        else:
+            msg = 'Deselected'
+        self.log.write("OnSelectCell: %s (%d,%d) %s\n" %
+                       (msg, evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+
+        # Another way to stay in a cell that has a bad value...
+        row = self.GetGridCursorRow()
+        col = self.GetGridCursorCol()
+
+        if self.IsCellEditControlEnabled():
+            self.HideCellEditControl()
+            self.DisableCellEditControl()
+
+        value = self.GetCellValue(row, col)
+
+        if value == 'no good 2':
+            return  # cancels the cell selection
+
+        evt.Skip()
+
+
+    def OnEditorShown(self, evt):
+        if evt.GetRow() == 6 and evt.GetCol() == 3 and \
+           wx.MessageBox("Are you sure you wish to edit this cell?",
+                        "Checking", wx.YES_NO) == wx.NO:
+            evt.Veto()
+            return
+
+        self.log.write("OnEditorShown: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+
+    def OnEditorHidden(self, evt):
+        if evt.GetRow() == 6 and evt.GetCol() == 3 and \
+           wx.MessageBox("Are you sure you wish to  finish editing this cell?",
+                        "Checking", wx.YES_NO) == wx.NO:
+            evt.Veto()
+            return
+
+        self.log.write("OnEditorHidden: (%d,%d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetPosition()))
+        evt.Skip()
+
+
+    def OnEditorCreated(self, evt):
+        self.log.write("OnEditorCreated: (%d, %d) %s\n" %
+                       (evt.GetRow(), evt.GetCol(), evt.GetControl()))
+
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+    def __init__(self, parent, log):
+        wx.Frame.__init__(self, parent, -1, "Simple Grid Demo", size=(640,480))
+        self.grid = SimpleGrid(self, log)
+
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+    import sys
+    from wx.lib.mixins.inspection import InspectableApp
+    app = InspectableApp(False)
+    frame = TestFrame(None, sys.stdout)
+    frame.Show(True)
+    #import wx.lib.inspection
+    #wx.lib.inspection.InspectionTool().Show()
+    app.MainLoop()
+
+
+#---------------------------------------------------------------------------
+
+

wx/demo/GridStdEdRend.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+
+import random
+
+import wx
+import wx.grid as gridlib
+
+#---------------------------------------------------------------------------
+
+class MyCustomRenderer(gridlib.GridCellRenderer):
+    def __init__(self):
+        gridlib.GridCellRenderer.__init__(self)
+
+    def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+        super().Draw(grid, attr, dc, rect, row, col, isSelected)
+        dc.SetBackgroundMode(wx.SOLID)
+        dc.SetBrush(wx.Brush(wx.BLACK, wx.BRUSHSTYLE_SOLID))
+        dc.SetPen(wx.TRANSPARENT_PEN)
+        dc.DrawRectangle(rect)
+
+        dc.SetBackgroundMode(wx.TRANSPARENT)
+        dc.SetFont(attr.GetFont())
+
+        text = grid.GetCellValue(row, col)
+        colors = ["RED", "WHITE", "SKY BLUE"]
+        x = rect.x + 1
+        y = rect.y + 1
+
+        for ch in text:
+            dc.SetTextForeground(random.choice(colors))
+            dc.DrawText(ch, x, y)
+            w, h = dc.GetTextExtent(ch)
+            x = x + w
+            if x > rect.right - 5:
+                break
+
+
+    def GetBestSize(self, grid, attr, dc, row, col):
+        text = grid.GetCellValue(row, col)
+        dc.SetFont(attr.GetFont())
+        w, h = dc.GetTextExtent(text)
+        return wx.Size(w, h)
+
+
+    def Clone(self):
+        return MyCustomRenderer()
+
+
+#---------------------------------------------------------------------------
+
+rendererDemoData = [
+    ('GridCellStringRenderer\n(the default)', 'this is a text value', gridlib.GridCellStringRenderer, ()),
+    ('GridCellNumberRenderer', '12345', gridlib.GridCellNumberRenderer, ()),
+    ('GridCellFloatRenderer', '1234.5678', gridlib.GridCellFloatRenderer, (6,2)),
+    ('GridCellBoolRenderer', '1', gridlib.GridCellBoolRenderer, ()),
+    ('MyCustomRenderer', 'This is my renderer', MyCustomRenderer, ()),
+    ]
+
+editorDemoData = [
+    ('GridCellTextEditor\n(the default)', 'Here is some more text', gridlib.GridCellTextEditor, ()),
+    ('GridCellNumberEditor\nwith min,max', '101', gridlib.GridCellNumberEditor, (5, 10005)),
+    ('GridCellNumberEditor\nwithout bounds', '101', gridlib.GridCellNumberEditor, ()),
+    ('GridCellFloatEditor', '1234.5678', gridlib.GridCellFloatEditor, ()),
+    ('GridCellBoolEditor', '1', gridlib.GridCellBoolEditor, ()),
+    ('GridCellChoiceEditor', 'one', gridlib.GridCellChoiceEditor, (['one', 'two', 'three', 'four',
+                                                         'kick', 'Microsoft', 'out the',
+                                                         'door'], False)),
+    ]
+
+comboDemoData = [
+    ('GridCellNumberRenderer\nGridCellNumberEditor', '20792', gridlib.GridCellNumberRenderer, gridlib.GridCellNumberEditor),
+    ('GridCellBoolRenderer\nGridCellBoolEditor', '1', gridlib.GridCellBoolRenderer, gridlib.GridCellBoolEditor),
+    ]
+
+
+class EditorsAndRenderersGrid(gridlib.Grid):
+    def __init__(self, parent, log):
+        gridlib.Grid.__init__(self, parent, -1)
+        self.log = log
+
+        self.CreateGrid(25, 8)
+        renCol = 1
+        edCol = 4
+
+
+        self.SetCellValue(0, renCol, '''\
+Cell Renderers are used to draw
+the contents of the cell when they
+need to be refreshed.  Different
+types of Renderers can be plugged in
+to different cells in the grid, it can
+even be automatically determined based
+on the type of data in the cell.
+''')
+
+        self.SetCellValue(0, edCol, '''\
+Cell Editors are used when the
+value of the cell is edited by
+the user.  An editor class is
+wrapped around a an object
+derived from wxControl and it
+implements some methods required
+to integrate with the grid.
+''')
+
+        self.SetCellValue(16, renCol, '''\
+Here are some combinations of Editors and
+Renderers used together.
+''')
+
+        row = 2
+
+        for label, value, renderClass, args in rendererDemoData:
+            renderer = renderClass(*args)
+            self.SetCellValue(row, renCol, label)
+            self.SetCellValue(row, renCol+1, value)
+            self.SetCellRenderer(row, renCol+1, renderer)
+            row = row + 2
+
+
+        row = 2
+
+        for label, value, editorClass, args in editorDemoData:
+            editor = editorClass(*args)
+            self.SetCellValue(row, edCol, label)
+            self.SetCellValue(row, edCol+1, value)
+            self.SetCellEditor(row, edCol+1, editor)
+            row = row + 2
+
+
+        row = 18
+
+        for label, value, renClass, edClass in comboDemoData:
+            self.SetCellValue(row, renCol, label)
+            self.SetCellValue(row, renCol+1, value)
+            editor = edClass()
+            renderer = renClass()
+            self.SetCellEditor(row, renCol+1, editor)
+            self.SetCellRenderer(row, renCol+1, renderer)
+            row = row + 2
+
+        font = self.GetFont()
+        font.SetWeight(wx.FONTWEIGHT_BOLD)
+        attr = gridlib.GridCellAttr()
+        attr.SetFont(font)
+        attr.SetBackgroundColour(wx.LIGHT_GREY)
+        attr.SetReadOnly(True)
+        attr.SetAlignment(wx.RIGHT, -1)
+        self.SetColAttr(renCol, attr)
+        attr.IncRef()
+        self.SetColAttr(edCol, attr)
+
+        # There is a bug in wxGTK for this method...
+        self.AutoSizeColumns(True)
+        self.AutoSizeRows(True)
+
+        self.Bind(gridlib.EVT_GRID_CELL_LEFT_DCLICK, self.OnLeftDClick)
+
+
+    # I do this because I don't like the default behaviour of not starting the
+    # cell editor on double clicks, but only a second click.
+    def OnLeftDClick(self, evt):
+        if self.CanEnableCellControl():
+            self.EnableCellEditControl()
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+    def __init__(self, parent, log):
+        wx.Frame.__init__(self, parent, -1, "Editors and Renderers Demo", size=(640,480))
+        grid = EditorsAndRenderersGrid(self, log)
+
+
+
+#---------------------------------------------------------------------------
+
+if __name__ == '__main__':
+    import sys
+    app = wx.App()
+    frame = TestFrame(None, sys.stdout)
+    frame.Show(True)
+    app.MainLoop()
+
+
+#---------------------------------------------------------------------------