wxPython/wx/lib/grids.py

   1 #----------------------------------------------------------------------
   2 # Name:        wxPython.lib.grids
   3 # Purpose:     An example sizer derived from the C++ wxPySizer that
   4 #              sizes items in a fixed or flexible grid.
   5 #
   6 # Author:      Robin Dunn
   7 #
   8 # Created:     21-Sept-1999
   9 # RCS-ID:      $Id$
  10 # Copyright:   (c) 1999 by Total Control Software
  11 # Licence:     wxWindows license
  12 #----------------------------------------------------------------------
  13 # 12/07/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  14 #
  15 # o 2.5 Compatability changes
  16 #
  17
  18 """
  19 In this module you will find wxGridSizer and wxFlexGridSizer.  Please
  20 note that these sizers have since been ported to C++ and those
  21 versions are now exposed in the regular wxPython wrappers.  However I
  22 am also leaving them here in the library so they can serve as an
  23 example of how to implement sizers in Python.
  24
  25 wxGridSizer: Sizes and positions items such that all rows are the same
  26 height and all columns are the same width.  You can specify a gap in
  27 pixels to be used between the rows and/or the columns.  When you
  28 create the sizer you specify the number of rows or the number of
  29 columns and then as you add items it figures out the other dimension
  30 automatically.  Like other sizers, items can be set to fill their
  31 available space, or to be aligned on a side, in a corner, or in the
  32 center of the space.  When the sizer is resized, all the items are
  33 resized the same amount so all rows and all columns remain the same
  34 size.
  35
  36 wxFlexGridSizer: Derives from wxGridSizer and adds the ability for
  37 particular rows and/or columns to be marked as growable.  This means
  38 that when the sizer changes size, the growable rows and colums are the
  39 ones that stretch.  The others remain at their initial size.
  40 """
  41
  42
  43 import  operator
  44 import  wx
  45
  46 #----------------------------------------------------------------------
  47
  48 class wxGridSizer(wx.PySizer):
  49     def __init__(self, rows=0, cols=0, hgap=0, vgap=0):
  50         wx.PySizer.__init__(self)
  51         if rows == 0 and cols == 0:
  52             raise ValueError, "rows and cols cannot both be zero"
  53
  54         self.rows = rows
  55         self.cols = cols
  56         self.hgap = hgap
  57         self.vgap = vgap
  58
  59
  60     def SetRows(self, rows):
  61         if rows == 0 and self.cols == 0:
  62             raise ValueError, "rows and cols cannot both be zero"
  63         self.rows = rows
  64
  65     def SetColumns(self, cols):
  66         if self.rows == 0 and cols == 0:
  67             raise ValueError, "rows and cols cannot both be zero"
  68         self.cols = cols
  69
  70     def GetRows(self):
  71         return self.rows
  72
  73     def GetColumns(self):
  74         return self.cols
  75
  76     def SetHgap(self, hgap):
  77         self.hgap = hgap
  78
  79     def SetVgap(self, vgap):
  80         self.vgap = vgap
  81
  82     def GetHgap(self, hgap):
  83         return self.hgap
  84
  85     def GetVgap(self, vgap):
  86         return self.vgap
  87
  88     #--------------------------------------------------
  89     def CalcMin(self):
  90         items = self.GetChildren()
  91         nitems = len(items)
  92         nrows = self.rows
  93         ncols = self.cols
  94
  95         if ncols > 0:
  96             nrows = (nitems + ncols-1) / ncols
  97         else:
  98             ncols = (nitems + nrows-1) / nrows
  99
 100         # Find the max width and height for any component.
 101         w = 0
 102         h = 0
 103         for item in items:
 104             size = item.CalcMin()
 105             w = max(w, size.width)
 106             h = max(h, size.height)
 107
 108         return wx.Size(ncols * w + (ncols-1) * self.hgap,
 109                        nrows * h + (nrows-1) * self.vgap)
 110
 111
 112     #--------------------------------------------------
 113     def RecalcSizes(self):
 114         items = self.GetChildren()
 115         if not items:
 116             return
 117
 118         nitems = len(items)
 119         nrows = self.rows
 120         ncols = self.cols
 121
 122         if ncols > 0:
 123             nrows = (nitems + ncols-1) / ncols
 124         else:
 125             ncols = (nitems + nrows-1) / nrows
 126
 127
 128         sz = self.GetSize()
 129         pt = self.GetPosition()
 130         w = (sz.width  - (ncols - 1) * self.hgap) / ncols;
 131         h = (sz.height - (nrows - 1) * self.vgap) / nrows;
 132
 133         x = pt.x
 134         for c in range(ncols):
 135             y = pt.y
 136             for r in range(nrows):
 137                 i = r * ncols + c
 138                 if i < nitems:
 139                     self.SetItemBounds(items[i], x, y, w, h)
 140
 141                 y = y + h + self.vgap
 142
 143             x = x + w + self.hgap
 144
 145
 146     #--------------------------------------------------
 147     def SetItemBounds(self, item, x, y, w, h):
 148         # calculate the item's size and position within
 149         # its grid cell
 150         ipt = wx.Point(x, y)
 151         isz = item.CalcMin()
 152         flag = item.GetFlag()
 153
 154         if flag & wx.EXPAND or flag & wx.SHAPED:
 155             isz = (w, h)
 156         else:
 157             if flag & wx.ALIGN_CENTER_HORIZONTAL:
 158                 ipt.x = x + (w - isz.width) / 2
 159             elif flag & wx.ALIGN_RIGHT:
 160                 ipt.x = x + (w - isz.width)
 161
 162             if flag & wx.ALIGN_CENTER_VERTICAL:
 163                 ipt.y = y + (h - isz.height) / 2
 164             elif flag & wx.ALIGN_BOTTOM:
 165                 ipt.y = y + (h - isz.height)
 166
 167         item.SetDimension(ipt, isz)
 168
 169
 170 #----------------------------------------------------------------------
 171
 172
 173
 174 class wxFlexGridSizer(wxGridSizer):
 175     def __init__(self, rows=0, cols=0, hgap=0, vgap=0):
 176         wxGridSizer.__init__(self, rows, cols, hgap, vgap)
 177         self.rowHeights = []
 178         self.colWidths  = []
 179         self.growableRows = []
 180         self.growableCols = []
 181
 182     def AddGrowableRow(self, idx):
 183         self.growableRows.append(idx)
 184
 185     def AddGrowableCol(self, idx):
 186         self.growableCols.append(idx)
 187
 188     #--------------------------------------------------
 189     def CalcMin(self):
 190         items = self.GetChildren()
 191         nitems = len(items)
 192         nrows = self.rows
 193         ncols = self.cols
 194
 195         if ncols > 0:
 196             nrows = (nitems + ncols-1) / ncols
 197         else:
 198             ncols = (nitems + nrows-1) / nrows
 199
 200         # Find the max width and height for any component.
 201         self.rowHeights = [0] * nrows
 202         self.colWidths  = [0] * ncols
 203
 204         for i in range(len(items)):
 205             size = items[i].CalcMin()
 206             row  = i / ncols
 207             col  = i % ncols
 208             self.rowHeights[row] = max(size.height, self.rowHeights[row])
 209             self.colWidths[col]  = max(size.width,  self.colWidths[col])
 210
 211         # Add up all the widths and heights
 212         cellsWidth = reduce(operator.__add__, self.colWidths)
 213         cellHeight = reduce(operator.__add__, self.rowHeights)
 214
 215         return wx.Size(cellsWidth + (ncols-1) * self.hgap,
 216                        cellHeight + (nrows-1) * self.vgap)
 217
 218
 219     #--------------------------------------------------
 220     def RecalcSizes(self):
 221         items = self.GetChildren()
 222         if not items:
 223             return
 224
 225         nitems = len(items)
 226         nrows = self.rows
 227         ncols = self.cols
 228
 229         if ncols > 0:
 230             nrows = (nitems + ncols-1) / ncols
 231         else:
 232             ncols = (nitems + nrows-1) / nrows
 233
 234         minsz = self.CalcMin()
 235         sz = self.GetSize()
 236         pt = self.GetPosition()
 237
 238         # Check for growables
 239         if self.growableRows and sz.height > minsz.height:
 240             delta = (sz.height - minsz.height) / len(self.growableRows)
 241             for idx in self.growableRows:
 242                 self.rowHeights[idx] = self.rowHeights[idx] + delta
 243
 244         if self.growableCols and sz.width > minsz.width:
 245             delta = (sz.width - minsz.width) / len(self.growableCols)
 246             for idx in self.growableCols:
 247                 self.colWidths[idx] = self.colWidths[idx] + delta
 248
 249         # bottom right corner
 250         sz = wx.Size(pt.x + sz.width, pt.y + sz.height)
 251
 252         # Layout each cell
 253         x = pt.x
 254         for c in range(ncols):
 255             y = pt.y
 256             for r in range(nrows):
 257                 i = r * ncols + c
 258
 259                 if i < nitems:
 260                     w = max(0, min(self.colWidths[c], sz.width - x))
 261                     h = max(0, min(self.rowHeights[r], sz.height - y))
 262                     self.SetItemBounds(items[i], x, y, w, h)
 263
 264                 y = y + self.rowHeights[r] + self.vgap
 265
 266             x = x + self.colWidths[c] + self.hgap
 267
 268 #----------------------------------------------------------------------
 269
 270
 271
 272
 273
 274