--- /dev/null
+# 11/18/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+#
+
+import wx
+import wx.grid as Grid
+
+import images
+
+class MegaTable(Grid.PyGridTableBase):
+ """
+ A custom wxGrid Table using user supplied data
+ """
+ def __init__(self, data, colnames, plugins):
+ """data is a list of the form
+ [(rowname, dictionary),
+ dictionary.get(colname, None) returns the data for column
+ colname
+ """
+ # The base class must be initialized *first*
+ Grid.PyGridTableBase.__init__(self)
+ self.data = data
+ self.colnames = colnames
+ self.plugins = plugins or {}
+ # XXX
+ # we need to store the row length and column length to
+ # see if the table has changed size
+ self._rows = self.GetNumberRows()
+ self._cols = self.GetNumberCols()
+
+ def GetNumberCols(self):
+ return len(self.colnames)
+
+ def GetNumberRows(self):
+ return len(self.data)
+
+ def GetColLabelValue(self, col):
+ return self.colnames[col]
+
+ def GetRowLabelValue(self, row):
+ return "row %03d" % int(self.data[row][0])
+
+ def GetValue(self, row, col):
+ return str(self.data[row][1].get(self.GetColLabelValue(col), ""))
+
+ def GetRawValue(self, row, col):
+ return self.data[row][1].get(self.GetColLabelValue(col), "")
+
+ def SetValue(self, row, col, value):
+ self.data[row][1][self.GetColLabelValue(col)] = value
+
+ def ResetView(self, grid):
+ """
+ (Grid) -> Reset the grid view. Call this to
+ update the grid if rows and columns have been added or deleted
+ """
+ grid.BeginBatch()
+
+ for current, new, delmsg, addmsg in [
+ (self._rows, self.GetNumberRows(), Grid.GRIDTABLE_NOTIFY_ROWS_DELETED, Grid.GRIDTABLE_NOTIFY_ROWS_APPENDED),
+ (self._cols, self.GetNumberCols(), Grid.GRIDTABLE_NOTIFY_COLS_DELETED, Grid.GRIDTABLE_NOTIFY_COLS_APPENDED),
+ ]:
+
+ if new < current:
+ msg = Grid.GridTableMessage(self,delmsg,new,current-new)
+ grid.ProcessTableMessage(msg)
+ elif new > current:
+ msg = Grid.GridTableMessage(self,addmsg,new-current)
+ grid.ProcessTableMessage(msg)
+ self.UpdateValues(grid)
+
+ grid.EndBatch()
+
+ self._rows = self.GetNumberRows()
+ self._cols = self.GetNumberCols()
+ # update the column rendering plugins
+ self._updateColAttrs(grid)
+
+ # update the scrollbars and the displayed part of the grid
+ grid.AdjustScrollbars()
+ grid.ForceRefresh()
+
+
+ def UpdateValues(self, grid):
+ """Update all displayed values"""
+ # This sends an event to the grid table to update all of the values
+ msg = Grid.GridTableMessage(self, Grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)
+ grid.ProcessTableMessage(msg)
+
+ def _updateColAttrs(self, grid):
+ """
+ wxGrid -> update the column attributes to add the
+ appropriate renderer given the column name. (renderers
+ are stored in the self.plugins dictionary)
+
+ Otherwise default to the default renderer.
+ """
+ col = 0
+
+ for colname in self.colnames:
+ attr = Grid.GridCellAttr()
+ if colname in self.plugins:
+ renderer = self.plugins[colname](self)
+
+ if renderer.colSize:
+ grid.SetColSize(col, renderer.colSize)
+
+ if renderer.rowSize:
+ grid.SetDefaultRowSize(renderer.rowSize)
+
+ attr.SetReadOnly(True)
+ attr.SetRenderer(renderer)
+
+ grid.SetColAttr(col, attr)
+ col += 1
+
+ # ------------------------------------------------------
+ # begin the added code to manipulate the table (non wx related)
+ def AppendRow(self, row):
+ #print 'append'
+ entry = {}
+
+ for name in self.colnames:
+ entry[name] = "Appended_%i"%row
+
+ # XXX Hack
+ # entry["A"] can only be between 1..4
+ entry["A"] = random.choice(range(4))
+ self.data.insert(row, ["Append_%i"%row, entry])
+
+ def DeleteCols(self, cols):
+ """
+ cols -> delete the columns from the dataset
+ cols hold the column indices
+ """
+ # we'll cheat here and just remove the name from the
+ # list of column names. The data will remain but
+ # it won't be shown
+ deleteCount = 0
+ cols = cols[:]
+ cols.sort()
+
+ for i in cols:
+ self.colnames.pop(i-deleteCount)
+ # we need to advance the delete count
+ # to make sure we delete the right columns
+ deleteCount += 1
+
+ if not len(self.colnames):
+ self.data = []
+
+ def DeleteRows(self, rows):
+ """
+ rows -> delete the rows from the dataset
+ rows hold the row indices
+ """
+ deleteCount = 0
+ rows = rows[:]
+ rows.sort()
+
+ for i in rows:
+ self.data.pop(i-deleteCount)
+ # we need to advance the delete count
+ # to make sure we delete the right rows
+ deleteCount += 1
+
+ def SortColumn(self, col):
+ """
+ col -> sort the data based on the column indexed by col
+ """
+ name = self.colnames[col]
+ _data = []
+
+ for row in self.data:
+ rowname, entry = row
+ _data.append((entry.get(name, None), row))
+
+ _data.sort()
+ self.data = []
+
+ for sortvalue, row in _data:
+ self.data.append(row)
+
+ # end table manipulation code
+ # ----------------------------------------------------------
+
+
+# --------------------------------------------------------------------
+# Sample wxGrid renderers
+
+class MegaImageRenderer(Grid.PyGridCellRenderer):
+ def __init__(self, table):
+ """
+ Image Renderer Test. This just places an image in a cell
+ based on the row index. There are N choices and the
+ choice is made by choice[row%N]
+ """
+ Grid.PyGridCellRenderer.__init__(self)
+ self.table = table
+ self._choices = [images.getSmilesBitmap,
+ images.getMondrianBitmap,
+ images.get_10s_Bitmap,
+ images.get_01c_Bitmap]
+
+ self.colSize = None
+ self.rowSize = None
+
+ def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+ choice = self.table.GetRawValue(row, col)
+ bmp = self._choices[ choice % len(self._choices)]()
+ image = wx.MemoryDC()
+ image.SelectObject(bmp)
+
+ # clear the background
+ dc.SetBackgroundMode(wx.SOLID)
+
+ if isSelected:
+ dc.SetBrush(wx.Brush(wx.BLUE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.BLUE, 1, wx.SOLID))
+ else:
+ dc.SetBrush(wx.Brush(wx.WHITE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.WHITE, 1, wx.SOLID))
+ dc.DrawRectangleRect(rect)
+
+ #dc.DrawRectangle((rect.x, rect.y), (rect.width, rect.height))
+
+ # copy the image but only to the size of the grid cell
+ width, height = bmp.GetWidth(), bmp.GetHeight()
+
+ if width > rect.width-2:
+ width = rect.width-2
+
+ if height > rect.height-2:
+ height = rect.height-2
+
+ dc.Blit((rect.x+1, rect.y+1), (width, height),
+ image,
+ (0, 0), wx.COPY, True)
+
+
+class MegaFontRenderer(Grid.PyGridCellRenderer):
+ def __init__(self, table, color="blue", font="ARIAL", fontsize=8):
+ """Render data in the specified color and font and fontsize"""
+ Grid.PyGridCellRenderer.__init__(self)
+ self.table = table
+ self.color = color
+ self.font = wx.Font(fontsize, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, font)
+ self.selectedBrush = wx.Brush("blue", wx.SOLID)
+ self.normalBrush = wx.Brush(wx.WHITE, wx.SOLID)
+ self.colSize = None
+ self.rowSize = 50
+
+ def Draw(self, grid, attr, dc, rect, row, col, isSelected):
+ # Here we draw text in a grid cell using various fonts
+ # and colors. We have to set the clipping region on
+ # the grid's DC, otherwise the text will spill over
+ # to the next cell
+ dc.SetClippingRect(rect)
+
+ # clear the background
+ dc.SetBackgroundMode(wx.SOLID)
+
+ if isSelected:
+ dc.SetBrush(wx.Brush(wx.BLUE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.BLUE, 1, wx.SOLID))
+ else:
+ dc.SetBrush(wx.Brush(wx.WHITE, wx.SOLID))
+ dc.SetPen(wx.Pen(wx.WHITE, 1, wx.SOLID))
+ dc.DrawRectangleRect(rect)
+
+ #dc.DrawRectangle((rect.x, rect.y), (rect.width, rect.height))
+
+ text = self.table.GetValue(row, col)
+ dc.SetBackgroundMode(wx.SOLID)
+
+ # change the text background based on whether the grid is selected
+ # or not
+ if isSelected:
+ dc.SetBrush(self.selectedBrush)
+ dc.SetTextBackground("blue")
+ else:
+ dc.SetBrush(self.normalBrush)
+ dc.SetTextBackground("white")
+
+ dc.SetTextForeground(self.color)
+ dc.SetFont(self.font)
+ dc.DrawText(text, (rect.x+1, rect.y+1))
+
+ # Okay, now for the advanced class :)
+ # Let's add three dots "..."
+ # to indicate that that there is more text to be read
+ # when the text is larger than the grid cell
+
+ width, height = dc.GetTextExtent(text)
+
+ if width > rect.width-2:
+ width, height = dc.GetTextExtent("...")
+ x = rect.x+1 + rect.width-2 - width
+ dc.DrawRectangle((x, rect.y+1), (width+1, height))
+ dc.DrawText("...", (x, rect.y+1))
+
+ dc.DestroyClippingRegion()
+
+
+# --------------------------------------------------------------------
+# Sample Grid using a specialized table and renderers that can
+# be plugged in based on column names
+
+class MegaGrid(Grid.Grid):
+ def __init__(self, parent, data, colnames, plugins=None):
+ """parent, data, colnames, plugins=None
+ Initialize a grid using the data defined in data and colnames
+ (see MegaTable for a description of the data format)
+ plugins is a dictionary of columnName -> column renderers.
+ """
+
+ # The base class must be initialized *first*
+ Grid.Grid.__init__(self, parent, -1)
+ self._table = MegaTable(data, colnames, plugins)
+ self.SetTable(self._table)
+ self._plugins = plugins
+
+ self.Bind(Grid.EVT_GRID_LABEL_RIGHT_CLICK, self.OnLabelRightClicked)
+
+ def Reset(self):
+ """reset the view based on the data in the table. Call
+ this when rows are added or destroyed"""
+ self._table.ResetView(self)
+
+ def OnLabelRightClicked(self, evt):
+ # Did we click on a row or a column?
+ row, col = evt.GetRow(), evt.GetCol()
+ if row == -1: self.colPopup(col, evt)
+ elif col == -1: self.rowPopup(row, evt)
+
+ def rowPopup(self, row, evt):
+ """(row, evt) -> display a popup menu when a row label is right clicked"""
+ appendID = wx.NewId()
+ deleteID = wx.NewId()
+ x = self.GetRowSize(row)/2
+
+ if not self.GetSelectedRows():
+ self.SelectRow(row)
+
+ menu = wx.Menu()
+ xo, yo = evt.GetPosition()
+ menu.Append(appendID, "Append Row")
+ menu.Append(deleteID, "Delete Row(s)")
+
+ def append(event, self=self, row=row):
+ self._table.AppendRow(row)
+ self.Reset()
+
+ def delete(event, self=self, row=row):
+ rows = self.GetSelectedRows()
+ self._table.DeleteRows(rows)
+ self.Reset()
+
+ self.Bind(wx.EVT_MENU, append, id=appendID)
+ self.Bind(wx.EVT_MENU, delete, id=deleteID)
+ self.PopupMenu(menu, (x, yo))
+ menu.Destroy()
+ return
+
+
+ def colPopup(self, col, evt):
+ """(col, evt) -> display a popup menu when a column label is
+ right clicked"""
+ x = self.GetColSize(col)/2
+ menu = wx.Menu()
+ id1 = wx.NewId()
+ sortID = wx.NewId()
+
+ xo, yo = evt.GetPosition()
+ self.SelectCol(col)
+ cols = self.GetSelectedCols()
+ self.Refresh()
+ menu.Append(id1, "Delete Col(s)")
+ menu.Append(sortID, "Sort Column")
+
+ def delete(event, self=self, col=col):
+ cols = self.GetSelectedCols()
+ self._table.DeleteCols(cols)
+ self.Reset()
+
+ def sort(event, self=self, col=col):
+ self._table.SortColumn(col)
+ self.Reset()
+
+ self.Bind(wx.EVT_MENU, delete, id=id1)
+
+ if len(cols) == 1:
+ self.Bind(wx.EVT_MENU, sort, id=sortID)
+
+ self.PopupMenu(menu, (xo, 0))
+ menu.Destroy()
+ return
+
+# -----------------------------------------------------------------
+# Test data
+# data is in the form
+# [rowname, dictionary]
+# where dictionary.get(colname, None) -> returns the value for the cell
+#
+# the colname must also be supplied
+import random
+colnames = ["Row", "This", "Is", "A", "Test"]
+
+data = []
+
+for row in range(1000):
+ d = {}
+ for name in ["This", "Test", "Is"]:
+ d[name] = random.random()
+
+ d["Row"] = len(data)
+ # XXX
+ # the "A" column can only be between one and 4
+ d["A"] = random.choice(range(4))
+ data.append((str(row), d))
+
+class MegaFontRendererFactory:
+ def __init__(self, color, font, fontsize):
+ """
+ (color, font, fontsize) -> set of a factory to generate
+ renderers when called.
+ func = MegaFontRenderFactory(color, font, fontsize)
+ renderer = func(table)
+ """
+ self.color = color
+ self.font = font
+ self.fontsize = fontsize
+
+ def __call__(self, table):
+ return MegaFontRenderer(table, self.color, self.font, self.fontsize)
+
+
+#---------------------------------------------------------------------------
+
+class TestFrame(wx.Frame):
+ def __init__(self, parent, plugins={"This":MegaFontRendererFactory("red", "ARIAL", 8),
+ "A":MegaImageRenderer,
+ "Test":MegaFontRendererFactory("orange", "TIMES", 24),}):
+ wx.Frame.__init__(self, parent, -1,
+ "Test Frame", size=(640,480))
+
+ grid = MegaGrid(self, data, colnames, plugins)
+ grid.Reset()
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+ win = TestFrame(frame)
+ frame.otherWin = win
+ win.Show(True)
+
+
+
+overview = """Mega Grid Example
+
+This example attempts to show many examples and tricks of
+using a virtual grid object. Hopefully the source isn't too jumbled.
+
+Features:
+<ol>
+ <li>Uses a virtual grid
+ <li>Columns and rows have popup menus (right click on labels)
+ <li>Columns and rows can be deleted (i.e. table can be
+ resized)
+ <li>Dynamic renderers. Renderers are plugins based on
+ column header name. Shows a simple Font Renderer and
+ an Image Renderer.
+</ol>
+
+Look for 'XXX' in the code to indicate some workarounds for non-obvious
+behavior and various hacks.
+
+"""
+
+
+if __name__ == '__main__':
+ import sys,os
+ import run
+ run.main(['', os.path.basename(sys.argv[0])])
+
projects / wxWidgets.git / blobdiff