1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
| #!/usr/bin/env python
import sys
try:
from PySide6 import QtCore, QtGui, QtWidgets
except ImportError as err:
print(err)
print("ERREUR: installez pyside 6 !")
exit(13)
fichier_datas = [
["Pierre", 500, 75, 8_500],
["Paul", 5, 78, 18_500],
["Pauline", 200, 75, 28_500],
["Pascal", 50, 35, 1_500],
["Boss", 200, 75, 18_500],
]
entete = ("Vendeur", "Ventes", "Secteur", "CA")
class MainModel(QtCore.QAbstractTableModel):
# Modèle simple fichier CSV avec entete
def __init__(self, data, heads):
super().__init__()
self._data = data
self._head = heads
def columnCount(self, index):
return len(self._data[0])
def rowCount(self, index):
return len(self._data)
def data(self, index, role):
if not index.isValid():
return False
if role in (QtCore.Qt.ItemDataRole.DisplayRole, QtCore.Qt.ItemDataRole.EditRole):
return self._data[index.row()][index.column()]
def headerData(self, section: int, orientation: QtCore.Qt.Orientation, role: int = ...):
if role != QtCore.Qt.ItemDataRole.DisplayRole:
return None
if orientation == QtCore.Qt.Orientation.Horizontal:
return self._head[section].capitalize()
if orientation == QtCore.Qt.Orientation.Vertical:
return f"{section + 1}"
class ToolProxyModel(QtCore.QSortFilterProxyModel):
"""utilitaire général pour remplir petits widgets (combo, autocompletion, ...)"""
# recup une seule colonne du modèle principal
def __init__(self, column: int = 0, duplicate=True, miniLong=2):
super().__init__()
self._column = 0
self.group = None if duplicate else set()
self.minilong = miniLong - 1
self.setFilterCaseSensitivity(QtCore.Qt.CaseSensitivity.CaseInsensitive)
self.column = column
self.setDynamicSortFilter(True)
def columnCount(self, parent=...) -> int:
return 1
def filterAcceptsRow(self, source_row: int, source_parent: QtCore.QModelIndex) -> bool:
index = self.sourceModel().index(source_row, self.column, source_parent)
data = str(self.sourceModel().data(index, QtCore.Qt.ItemDataRole.DisplayRole))
# règle métier, normalement méthode
result = len(data) > self.minilong
if result and self.group is not None:
# valeurs unique
data = data.casefold()
if data in self.group:
return False
self.group.add(data)
return result
def filterAcceptsColumn(self, source_column: int, source_parent: QtCore.QModelIndex) -> bool:
"""on accepte qu'une seule colonne"""
if self.group:
self.group.clear()
return source_column == self.column
@property
def column(self):
"""ne récupère que cette colonne du modèle"""
return self._column
@column.setter
def column(self, value: int):
self._column = value
self._refresh()
def _refresh(self):
"""au changement des setters, actualiser vue"""
self.beginResetModel()
self.layoutChanged.emit()
self.endResetModel()
class MainProxyModel(QtCore.QSortFilterProxyModel):
"""
filtre(s) sur modèle principal (tableau) adaptable pour un métier particulier
"""
ROLE_STR = 0
ROLE_EGAL = 1 # a écrire des filtres classiques
ROLE_REGEX = 2
ROLE_DATE = 3
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.filters = {} # 1 filtre par colonne
def setFilterByColumn(self, regex: str, column: int, role=0, callback=None):
if regex != "":
self.filters[column] = (regex.lower(), role, callback)
else:
del self.filters[column]
self.invalidateFilter()
print("filtres:", self.filters)
def filterAcceptsRow(self, source_row, source_parent):
""" filtre(s) sur plusieurs colonnes """
for column, data in self.filters.items():
regex, role, callback = data
if regex == "":
break
if callback:
return callback(self, source_row, source_parent, column, regex)
match role:
case self.ROLE_STR:
return self._filter_str(source_row, source_parent, column, regex)
case _ :
return False
return True
def _filter_str(self, source_row, source_parent, column, regex):
""" un des filtre "métier" générique """
index = self.sourceModel().index(source_row, column, source_parent)
if not index.isValid():
return False
if text := str(self.sourceModel().data(index, QtCore.Qt.ItemDataRole.DisplayRole)):
if regex not in text.lower():
return False
return True
class filter_plugin_interval(): #TODO définir Interface
""" un filtre spécifique métier """
# pour ne pas trop surcharger MainProxyModel ...
def run(proxy, source_row, source_parent, column, regex):
"""
un filtre "métier" spécifique : +10, -10 ou 10
Avec + et -, nous avons un interval
"""
index = proxy.sourceModel().index(source_row, column, source_parent)
if not index.isValid():
return False
if regex in ("+", "-"):
return True
action = "+" if str(regex).startswith("+") else None
if str(regex).startswith("-"): action = "-"
try:
value = int(proxy.sourceModel().data(index, QtCore.Qt.ItemDataRole.DisplayRole))
regex = abs(int(regex))
except ValueError:
return False
match action:
case "+" :
if regex >= value: return False
case "-" :
if regex <= value: return False
case _:
if regex != value: return False
return True
def getValidator():
return QtGui.QIntValidator()
###### GUI ######
class FilterLineEdit(QtWidgets.QLineEdit):
onFilter = QtCore.Signal(str, int, object)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = None
self.callback = None
self.setDisabled(True)
def setFilter(self, column, model=None, ToolProxyModelType=ToolProxyModel, callback=None, *args, **kwargs):
self.model = model
self.callback = callback
if callback:
self.setValidator(callback.getValidator())
if model:
completer = QtWidgets.QCompleter()
modelproxy = ToolProxyModelType(column=column, duplicate=False)
modelproxy.setSourceModel(model)
completer.setCaseSensitivity(QtCore.Qt.CaseSensitivity.CaseInsensitive)
completer.setModel(modelproxy)
self.setCompleter(completer)
self.textChanged.connect(self.onFiltrerChange)
name = self.model.headerData(column, QtCore.Qt.Orientation.Horizontal, QtCore.Qt.ItemDataRole.DisplayRole)
self.setToolTip(name)
self.setObjectName(f'FilterLineEdit_{name}')
self.setPlaceholderText("filtre")
self.setDisabled(False)
def onFiltrerChange(self, data):
if not self.model:
return
sender = self.sender()
col = sender.completer().model().column
#print("filtre:", sender, col, data)
self.onFilter.emit(data, col, self.callback.run if self.callback else None)
class FilterTable(QtWidgets.QWidget):
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
self.filters = []
self.filterModel = MainProxyModel()
self.filterModel.setSourceModel(self.model)
self.filterModel.setFilterKeyColumn(0)
self.table = QtWidgets.QTableView()
self.table.setModel(self.filterModel)
self.table.setSortingEnabled(True)
self.table.sortByColumn(0, QtCore.Qt.AscendingOrder)
if header := self.table.horizontalHeader():
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Stretch)
header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeMode.Interactive)
header.setStretchLastSection(True)
if mainLayout := QtWidgets.QVBoxLayout(self):
mainLayout.setSpacing(0)
mainLayout.setContentsMargins(0, 0, 0, 0)
mainLayout.addLayout(self.initToolsBar())
mainLayout.addWidget(self.table)
def initToolsBar(self):
# créer les widgets filtres
tools=QtWidgets.QHBoxLayout()
tools.setContentsMargins(20, 0, 0, 0)
for column in range(self.model.columnCount(0)):
# liaison des widgets à la BD
title = self.model.headerData(column, QtCore.Qt.Orientation.Horizontal, QtCore.Qt.ItemDataRole.DisplayRole)
print(column, title)
tool = FilterLineEdit(self)
tools.addWidget(tool)
self.filters.append(tool)
if column !=2: # pour démo, pas de filtre sur cette colonne
tool.setFilter(column, self.model, ToolProxyModel, filter_plugin_interval if column else None)
tool.onFilter.connect(self.onFiltrerChange)
#tool.setToolTip(title)
self.table.horizontalHeader().viewport().installEventFilter(self) # pour ajuster les tailles... voir eventFilter()
return tools
def onFiltrerChange(self, data, col, callback):
# un filtre a changé, les réapliquer tous sur le proyxModel lié à la vue
if isinstance(self.table.model(), QtCore.QSortFilterProxyModel):
self.table.model().setFilterByColumn(data, col, callback = callback)
def eventFilter(self, obj, event):
""" intercepter les tailles , puis forcer celles des gui filtres """
if isinstance(event, QtGui.QResizeEvent) or isinstance(event, QtGui.QPaintEvent):
x = self.filters[0].pos().x()
for i in range(self.model.columnCount(0)):
r = self.filters[i].size()
self.filters[i].resize(self.table.columnWidth(i), r.height())
self.filters[i].move(x, 0)
x += self.table.columnWidth(i)+1
return super().eventFilter(obj, event)
class MainWindow(QtWidgets.QMainWindow):
def __init__(self, datas, entete):
super().__init__()
model = MainModel(datas, entete)
self.statusBar()
self.table = FilterTable(model)
layout = QtWidgets.QVBoxLayout()
widget = QtWidgets.QWidget()
widget.setLayout(layout)
layout.addWidget(self.table)
if chart_view := self.init_chart():
layout.addWidget(QtWidgets.QLabel("Chiffre d'affaire", parent=self))
layout.addWidget(chart_view)
self.setCentralWidget(widget)
def init_chart(self):
""" on affiche un graphique lié au proxyModel (du tableau)"""
# on passe un paramètre quelconque à notre app si on désire en plus ce graphique
if len(sys.argv) < 2:
return None
from PySide6.QtCharts import QChart, QChartView, QPieSeries, QVPieModelMapper # qt6-charts
mapper = QVPieModelMapper(self)
mapper.setLabelsColumn(0)
mapper.setValuesColumn(3)
series = QPieSeries()
mapper.setSeries(series)
mapper.setModel(self.table.filterModel) # lié au modele filtré !
chart = QChart()
chart.addSeries(series)
chart.setMargins(QtCore.QMargins(0,0,0,0))
chart.setTheme(QChart.ChartThemeDark)
chart.setToolTip("Chiffre d'affaire")
chart_view = QChartView(chart)
chart_view.setRenderHint(QtGui.QPainter.Antialiasing)
chart_view.setMinimumSize(300, 210)
return chart_view
if __name__ == "__main__":
app=QtWidgets.QApplication(sys.argv)
win = MainWindow(fichier_datas, entete)
win.show()
sys.exit(app.exec()) |
Filtrer éléments d'un QTableWidget
Répondre avec citation
Envoyé par fred1599
utilité ???
) donc c'est une technique à n'utiliser qu'une seule fois !
Partager