]>
Commit | Line | Data |
---|---|---|
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 | def getListCtrlSelection(listctrl, state=wx.LIST_STATE_SELECTED): | |
272 | """ Returns list of item indexes of given state (selected by defaults) """ | |
273 | res = [] | |
274 | idx = -1 | |
275 | while 1: | |
276 | idx = listctrl.GetNextItem(idx, wx.LIST_NEXT_ALL, state) | |
277 | if idx == -1: | |
278 | break | |
279 | res.append(idx) | |
280 | return res | |
281 | ||
282 | wxEVT_DOPOPUPMENU = wx.NewEventType() | |
283 | EVT_DOPOPUPMENU = wx.PyEventBinder(wxEVT_DOPOPUPMENU, 0) | |
284 | ||
285 | class ListCtrlSelectionManagerMix: | |
286 | """Mixin that defines a platform independent selection policy | |
287 | ||
288 | As selection single and multi-select list return the item index or a | |
289 | list of item indexes respectively. | |
290 | """ | |
291 | _menu = None | |
292 | ||
293 | def __init__(self): | |
294 | self.Bind(wx.EVT_RIGHT_DOWN, self.OnLCSMRightDown) | |
295 | self.Bind(EVT_DOPOPUPMENU, self.OnLCSMDoPopup) | |
296 | # self.Connect(-1, -1, self.wxEVT_DOPOPUPMENU, self.OnLCSMDoPopup) | |
297 | ||
298 | def getPopupMenu(self): | |
299 | """ Override to implement dynamic menus (create) """ | |
300 | return self._menu | |
301 | ||
302 | def setPopupMenu(self, menu): | |
303 | """ Must be set for default behaviour """ | |
304 | self._menu = menu | |
305 | ||
306 | def afterPopupMenu(self, menu): | |
307 | """ Override to implement dynamic menus (destroy) """ | |
308 | pass | |
309 | ||
310 | def getSelection(self): | |
311 | res = getListCtrlSelection(self) | |
312 | if self.GetWindowStyleFlag() & wx.LC_SINGLE_SEL: | |
313 | if res: | |
314 | return res[0] | |
315 | else: | |
316 | return -1 | |
317 | else: | |
318 | return res | |
319 | ||
320 | def OnLCSMRightDown(self, event): | |
321 | selectBeforePopup(event) | |
322 | event.Skip() | |
323 | menu = self.getPopupMenu() | |
324 | if menu: | |
325 | evt = wx.PyEvent() | |
326 | evt.SetEventType(wxEVT_DOPOPUPMENU) | |
327 | evt.menu = menu | |
328 | evt.pos = event.GetPosition() | |
329 | wx.PostEvent(self, evt) | |
330 | ||
331 | def OnLCSMDoPopup(self, event): | |
332 | self.PopupMenu(event.menu, event.pos) | |
333 | self.afterPopupMenu(event.menu) | |
334 | ||
335 | #---------------------------------------------------------------------- |