wxPython/wx/lib/mixins/listctrl.py

   1 #----------------------------------------------------------------------------
   2 # Name:        wxPython.lib.mixins.listctrl
   3 # Purpose:     Helpful mix-in classes for wxListCtrl
   4 #
   5 # Author:      Robin Dunn
   6 #
   7 # Created:     15-May-2001
   8 # RCS-ID:      $Id$
   9 # Copyright:   (c) 2001 by Total Control Software
  10 # Licence:     wxWindows license
  11 #----------------------------------------------------------------------------
  12 # 12/14/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  13 #
  14 # o 2.5 compatability update.
  15 # o ListCtrlSelectionManagerMix untested.
  16 #
  17 # 12/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
  18 #
  19 # o wxColumnSorterMixin -> ColumnSorterMixin
  20 # o wxListCtrlAutoWidthMixin -> ListCtrlAutoWidthMixin
  21 #
  22
  23 import  locale
  24 import  wx
  25
  26 #----------------------------------------------------------------------------
  27
  28 class ColumnSorterMixin:
  29     """
  30     A mixin class that handles sorting of a wx.ListCtrl in REPORT mode when
  31     the column header is clicked on.
  32
  33     There are a few requirments needed in order for this to work genericly:
  34
  35       1. The combined class must have a GetListCtrl method that
  36          returns the wx.ListCtrl to be sorted, and the list control
  37          must exist at the time the wx.ColumnSorterMixin.__init__
  38          method is called because it uses GetListCtrl.
  39
  40       2. Items in the list control must have a unique data value set
  41          with list.SetItemData.
  42
  43       3. The combined class must have an attribute named itemDataMap
  44          that is a dictionary mapping the data values to a sequence of
  45          objects representing the values in each column.  These values
  46          are compared in the column sorter to determine sort order.
  47
  48     Interesting methods to override are GetColumnSorter,
  49     GetSecondarySortValues, and GetSortImages.  See below for details.
  50     """
  51
  52     def __init__(self, numColumns):
  53         self.SetColumnCount(numColumns)
  54         list = self.GetListCtrl()
  55         if not list:
  56             raise ValueError, "No wx.ListCtrl available"
  57         self.Bind(wx.EVT_LIST_COL_CLICK, self.__OnColClick, list)
  58
  59
  60     def SetColumnCount(self, newNumColumns):
  61         self._colSortFlag = [0] * newNumColumns
  62         self._col = -1
  63
  64
  65     def SortListItems(self, col=-1, ascending=1):
  66         """Sort the list on demand.  Can also be used to set the sort column and order."""
  67         oldCol = self._col
  68         if col != -1:
  69             self._col = col
  70             self._colSortFlag[col] = ascending
  71         self.GetListCtrl().SortItems(self.GetColumnSorter())
  72         self.__updateImages(oldCol)
  73
  74
  75     def GetColumnWidths(self):
  76         """
  77         Returns a list of column widths.  Can be used to help restore the current
  78         view later.
  79         """
  80         list = self.GetListCtrl()
  81         rv = []
  82         for x in range(len(self._colSortFlag)):
  83             rv.append(list.GetColumnWidth(x))
  84         return rv
  85
  86
  87     def GetSortImages(self):
  88         """
  89         Returns a tuple of image list indexesthe indexes in the image list for an image to be put on the column
  90         header when sorting in descending order.
  91         """
  92         return (-1, -1)  # (decending, ascending) image IDs
  93
  94
  95     def GetColumnSorter(self):
  96         """Returns a callable object to be used for comparing column values when sorting."""
  97         return self.__ColumnSorter
  98
  99
 100     def GetSecondarySortValues(self, col, key1, key2):
 101         """Returns a tuple of 2 values to use for secondary sort values when the
 102            items in the selected column match equal.  The default just returns the
 103            item data values."""
 104         return (key1, key2)
 105
 106
 107     def __OnColClick(self, evt):
 108         oldCol = self._col
 109         self._col = col = evt.GetColumn()
 110         self._colSortFlag[col] = not self._colSortFlag[col]
 111         self.GetListCtrl().SortItems(self.GetColumnSorter())
 112         self.__updateImages(oldCol)
 113         evt.Skip()
 114
 115
 116     def __ColumnSorter(self, key1, key2):
 117         col = self._col
 118         ascending = self._colSortFlag[col]
 119         item1 = self.itemDataMap[key1][col]
 120         item2 = self.itemDataMap[key2][col]
 121
 122         #--- Internationalization of string sorting with locale module
 123         if type(item1) == type('') or type(item2) == type(''):
 124             cmpVal = locale.strcoll(str(item1), str(item2))
 125         else:
 126             cmpVal = cmp(item1, item2)
 127         #---
 128
 129         # If the items are equal then pick something else to make the sort value unique
 130         if cmpVal == 0:
 131             cmpVal = apply(cmp, self.GetSecondarySortValues(col, key1, key2))
 132
 133         if ascending:
 134             return cmpVal
 135         else:
 136             return -cmpVal
 137
 138
 139     def __updateImages(self, oldCol):
 140         sortImages = self.GetSortImages()
 141         if self._col != -1 and sortImages[0] != -1:
 142             img = sortImages[self._colSortFlag[self._col]]
 143             list = self.GetListCtrl()
 144             if oldCol != -1:
 145                 list.ClearColumnImage(oldCol)
 146             list.SetColumnImage(self._col, img)
 147
 148
 149 #----------------------------------------------------------------------------
 150 #----------------------------------------------------------------------------
 151
 152 class ListCtrlAutoWidthMixin:
 153     """ A mix-in class that automatically resizes the last column to take up
 154         the remaining width of the wx.ListCtrl.
 155
 156         This causes the wx.ListCtrl to automatically take up the full width of
 157         the list, without either a horizontal scroll bar (unless absolutely
 158         necessary) or empty space to the right of the last column.
 159
 160         NOTE:    This only works for report-style lists.
 161
 162         WARNING: If you override the EVT_SIZE event in your wx.ListCtrl, make
 163                  sure you call event.Skip() to ensure that the mixin's
 164                  _OnResize method is called.
 165
 166         This mix-in class was written by Erik Westra <ewestra@wave.co.nz>
 167     """
 168     def __init__(self):
 169         """ Standard initialiser.
 170         """
 171         self._lastColMinWidth = None
 172
 173         self.Bind(wx.EVT_SIZE, self._onResize)
 174         self.Bind(wx.EVT_LIST_COL_END_DRAG, self._onResize, self)
 175
 176
 177     def resizeLastColumn(self, minWidth):
 178         """ Resize the last column appropriately.
 179
 180             If the list's columns are too wide to fit within the window, we use
 181             a horizontal scrollbar.  Otherwise, we expand the right-most column
 182             to take up the remaining free space in the list.
 183
 184             This method is called automatically when the wx.ListCtrl is resized;
 185             you can also call it yourself whenever you want the last column to
 186             be resized appropriately (eg, when adding, removing or resizing
 187             columns).
 188
 189             'minWidth' is the preferred minimum width for the last column.
 190         """
 191         self._lastColMinWidth = minWidth
 192         self._doResize()
 193
 194     # =====================
 195     # == Private Methods ==
 196     # =====================
 197
 198     def _onResize(self, event):
 199         """ Respond to the wx.ListCtrl being resized.
 200
 201             We automatically resize the last column in the list.
 202         """
 203         wx.CallAfter(self._doResize)
 204         event.Skip()
 205
 206
 207     def _doResize(self):
 208         """ Resize the last column as appropriate.
 209
 210             If the list's columns are too wide to fit within the window, we use
 211             a horizontal scrollbar.  Otherwise, we expand the right-most column
 212             to take up the remaining free space in the list.
 213
 214             We remember the current size of the last column, before resizing,
 215             as the preferred minimum width if we haven't previously been given
 216             or calculated a minimum width.  This ensure that repeated calls to
 217             _doResize() don't cause the last column to size itself too large.
 218         """
 219         numCols = self.GetColumnCount()
 220         if numCols == 0: return # Nothing to resize.
 221
 222         if self._lastColMinWidth == None:
 223             self._lastColMinWidth = self.GetColumnWidth(numCols - 1)
 224
 225         # We're showing the vertical scrollbar -> allow for scrollbar width
 226         # NOTE: on GTK, the scrollbar is included in the client size, but on
 227         # Windows it is not included
 228         listWidth = self.GetClientSize().width
 229         if wx.Platform != '__WXMSW__':
 230             if self.GetItemCount() > self.GetCountPerPage():
 231                 scrollWidth = wx.SystemSettings_GetMetric(wx.SYS_VSCROLL_X)
 232                 listWidth = listWidth - scrollWidth
 233
 234         totColWidth = 0 # Width of all columns except last one.
 235         for col in range(numCols-1):
 236             totColWidth = totColWidth + self.GetColumnWidth(col)
 237
 238         lastColWidth = self.GetColumnWidth(numCols - 1)
 239
 240         if totColWidth + self._lastColMinWidth > listWidth:
 241             # We haven't got the width to show the last column at its minimum
 242             # width -> set it to its minimum width and allow the horizontal
 243             # scrollbar to show.
 244             self.SetColumnWidth(numCols-1, self._lastColMinWidth)
 245             return
 246
 247         # Resize the last column to take up the remaining available space.
 248
 249         self.SetColumnWidth(numCols-1, listWidth - totColWidth)
 250
 251
 252
 253 #----------------------------------------------------------------------------
 254
 255 SEL_FOC = wx.LIST_STATE_SELECTED | wx.LIST_STATE_FOCUSED
 256 def selectBeforePopup(event):
 257     """Ensures the item the mouse is pointing at is selected before a popup.
 258
 259     Works with both single-select and multi-select lists."""
 260     ctrl = event.GetEventObject()
 261     if isinstance(ctrl, wxListCtrl):
 262         n, flags = ctrl.HitTest(event.GetPosition())
 263         if n >= 0:
 264             if not ctrl.GetItemState(n, wx.LIST_STATE_SELECTED):
 265                 for i in range(ctrl.GetItemCount()):
 266                     ctrl.SetItemState(i, 0, SEL_FOC)
 267                 #for i in getListCtrlSelection(ctrl, SEL_FOC):
 268                 #    ctrl.SetItemState(i, 0, SEL_FOC)
 269                 ctrl.SetItemState(n, SEL_FOC, SEL_FOC)
 270
 271
 272 def getListCtrlSelection(listctrl, state=wx.LIST_STATE_SELECTED):
 273     """ Returns list of item indexes of given state (selected by defaults) """
 274     res = []
 275     idx = -1
 276     while 1:
 277         idx = listctrl.GetNextItem(idx, wx.LIST_NEXT_ALL, state)
 278         if idx == -1:
 279             break
 280         res.append(idx)
 281     return res
 282
 283 wxEVT_DOPOPUPMENU = wx.NewEventType()
 284 EVT_DOPOPUPMENU = wx.PyEventBinder(wxEVT_DOPOPUPMENU, 0)
 285
 286
 287 class ListCtrlSelectionManagerMix:
 288     """Mixin that defines a platform independent selection policy
 289
 290     As selection single and multi-select list return the item index or a
 291     list of item indexes respectively.
 292     """
 293     _menu = None
 294
 295     def __init__(self):
 296         self.Bind(wx.EVT_RIGHT_DOWN, self.OnLCSMRightDown)
 297         self.Bind(EVT_DOPOPUPMENU, self.OnLCSMDoPopup)
 298 #        self.Connect(-1, -1, self.wxEVT_DOPOPUPMENU, self.OnLCSMDoPopup)
 299
 300
 301     def getPopupMenu(self):
 302         """ Override to implement dynamic menus (create) """
 303         return self._menu
 304
 305
 306     def setPopupMenu(self, menu):
 307         """ Must be set for default behaviour """
 308         self._menu = menu
 309
 310
 311     def afterPopupMenu(self, menu):
 312         """ Override to implement dynamic menus (destroy) """
 313         pass
 314
 315
 316     def getSelection(self):
 317         res = getListCtrlSelection(self)
 318         if self.GetWindowStyleFlag() & wx.LC_SINGLE_SEL:
 319             if res:
 320                 return res[0]
 321             else:
 322                 return -1
 323         else:
 324             return res
 325
 326
 327     def OnLCSMRightDown(self, event):
 328         selectBeforePopup(event)
 329         event.Skip()
 330         menu = self.getPopupMenu()
 331         if menu:
 332             evt = wx.PyEvent()
 333             evt.SetEventType(wxEVT_DOPOPUPMENU)
 334             evt.menu = menu
 335             evt.pos = event.GetPosition()
 336             wx.PostEvent(self, evt)
 337
 338
 339     def OnLCSMDoPopup(self, event):
 340         self.PopupMenu(event.menu, event.pos)
 341         self.afterPopupMenu(event.menu)
 342
 343
 344 #----------------------------------------------------------------------------
 345 from bisect import bisect
 346
 347
 348 class TextEditMixin:
 349     """
 350     A mixin class that handles enables any text in any column of a
 351     multi-column listctrl to be edited by clicking on the given row
 352     and column.  You close the text editor by hitting the ENTER key or
 353     clicking somewhere else on the listctrl. You switch to the next
 354     column by hiting TAB.
 355
 356     To use the mixin you have to include it in the class definition
 357     and call the __init__ function::
 358
 359         class TestListCtrl(wx.ListCtrl, TextEdit):
 360             def __init__(self, parent, ID, pos=wx.DefaultPosition,
 361                          size=wx.DefaultSize, style=0):
 362                 wx.ListCtrl.__init__(self, parent, ID, pos, size, style)
 363                 TextEdit.__init__(self)
 364
 365
 366     Authors:     Steve Zatz, Pim Van Heuven (pim@think-wize.com)
 367     """
 368
 369     def __init__(self):
 370         #editor = wx.TextCtrl(self, -1, pos=(-1,-1), size=(-1,-1),
 371         #                     style=wx.TE_PROCESS_ENTER|wx.TE_PROCESS_TAB \
 372         #                     |wx.TE_RICH2)
 373         editor = wx.PreTextCtrl()
 374         editor.Hide()
 375         editor.Create(self, -1, style=wx.TE_PROCESS_ENTER|wx.TE_PROCESS_TAB|wx.TE_RICH2)
 376         editor.SetBackgroundColour(wx.Colour(red=255,green=255,blue=175)) #Yellow
 377         font = self.GetFont()
 378         editor.SetFont(font)
 379
 380         self.editor = editor
 381         self.Bind(wx.EVT_TEXT_ENTER, self.CloseEditor)
 382         self.editor.Bind(wx.EVT_CHAR, self.OnChar)
 383         self.editor.Bind(wx.EVT_KILL_FOCUS, self.CloseEditor)
 384         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
 385         self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDown)
 386         self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnItemSelected)
 387         self.curRow = -1
 388
 389
 390     def OnItemSelected(self, evt):
 391         self.curRow = evt.GetIndex()
 392         evt.Skip()
 393
 394
 395     def OnChar(self, event):
 396         ''' Catch the TAB key code so we can open the editor at the next column (if any).'''
 397         if event.GetKeyCode() == wx.WXK_TAB:
 398             self.CloseEditor()
 399             if self.curCol+1 < self.GetColumnCount():
 400                 self.OpenEditor(self.curCol+1, self.curRow)
 401         else:
 402             event.Skip()
 403
 404
 405     def OnLeftDown(self, evt=None):
 406         ''' Examine the click and double
 407         click events to see if a row has been click on twice. If so,
 408         determine the current row and columnn and open the editor.'''
 409
 410         if self.editor.IsShown():
 411             self.CloseEditor()
 412
 413         x,y = evt.GetPosition()
 414         row,flags = self.HitTest((x,y))
 415
 416         if row != self.curRow: # self.curRow keeps track of the current row
 417             evt.Skip()
 418             return
 419
 420         # the following should really be done in the mixin's init but
 421         # the wx.ListCtrl demo creates the columns after creating the
 422         # ListCtrl (generally not a good idea) on the other hand,
 423         # doing this here handles adjustable column widths
 424
 425         self.col_locs = [0]
 426         loc = 0
 427         for n in range(self.GetColumnCount()):
 428             loc = loc + self.GetColumnWidth(n)
 429             self.col_locs.append(loc)
 430
 431         col = bisect(self.col_locs, x) - 1
 432         self.OpenEditor(col, row)
 433
 434
 435     def OpenEditor(self, col, row):
 436         ''' Opens an editor at the current position. '''
 437
 438         x0 = self.col_locs[col]
 439         x1 = self.col_locs[col+1] - x0
 440
 441         y0 = self.GetItemRect(row)[1]
 442
 443         editor = self.editor
 444         editor.SetDimensions(x0,y0, x1,-1)
 445         editor.SetValue(self.GetItem(row, col).GetText())
 446         editor.Show()
 447         editor.Raise()
 448         editor.SetSelection(-1,-1)
 449         editor.SetFocus()
 450
 451         self.curRow = row
 452         self.curCol = col
 453
 454
 455     def CloseEditor(self, evt=None):
 456         ''' Close the editor and save the new value to the ListCtrl. '''
 457         text = self.editor.GetValue()
 458         self.editor.Hide()
 459         self.SetStringItem(self.curRow, self.curCol, text)
 460
 461
 462
 463 #----------------------------------------------------------------------------