IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

PyQt Python Discussion :

Filtrer éléments d'un QTableWidget [QtGui]


Sujet :

PyQt Python

  1. #1
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut Filtrer éléments d'un QTableWidget
    Bonjour à tous
    Je cherche à filtrer les éléments d'un QTableWidget. C'est à dire avoir un QTableWidget qui contienne diverses valeurs (ok) mais pouvoir dire ensuite "n'affiche que les lignes qui ont telle valeur dans cette colonne".

    Ma première idée a été de mettre des QComboBox pour chaque colonne. La combo récupère toutes les valeurs disponibles de la colonne et ensuite, je filtre sur la combo choisie. Ca marche mais les largeurs des combo ne sont pas les mêmes que celles des colonnes du QTable et c'est moche.
    Ensuite je teste avec 2 QTableQidget, le premier servant à choisir les valeurs ce qui permet ensuite le filtre du second sur les valeurs choisies dans le premier. Et via un setItemDelegate je peux même mettre des combo dans les colonnes du premier. Ca marche mais souci, les 2 QTableWidget sont placés l'un au dessus de l'autre mais Qt m'affiche du vide entre les deux. Je n'arrive pas à dire au second "colle-toi sous le premier". Pourtant ils sont tous deux dans un layout vertical avec gestion du stretch mais non, le premier bien que n'ayant qu'une seule ligne reste affiché dans un espace plus grand que prévu et c'est moche.
    Nom : xxx.jpg
Affichages : 309
Taille : 53,5 Ko

    J'ai aussi pensé à ne mettre qu'un seul tablewidget et déléguer la toute première ligne au choix des valeurs, mais le souci c'est que le QTableWidget est "sortable" et si l'utilisateur active le tri, ça déplacera cette première ligne.

    Donc je reste sec. Si quelqu'un a une idée...

    Merci à tous
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  2. #2
    Expert confirmé
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    4 060
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 4 060
    Par défaut
    Hello,

    Pas de possibilité de reproduire cela sur un code simple ?

  3. #3
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Oui pas de souci (un peu long toutefois, j'y ai laissé le delegate)

    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #!/usr/bin/env python
    # coding: utf-8 -*-
     
    from PyQt5.QtWidgets import *
    from PyQt5.QtCore import *
    import sys
     
    class QtData(QWidget):
    	def __init__(self, data, *args, **kwargs):
    		super().__init__(*args, **kwargs)
    		self.resize(600, 300)
     
    		# La zone de sélection
    		self.__tableChoice=QTableWidget(0, 0, parent=self, itemChanged=self.__slotFiltre)
    		self.__tableChoice.setRowCount(1)
    		self.__tableChoice.setColumnCount(len(data[0]))
     
    		# L'éditeur de la zone de sélection
    		self.__tableChoice.setItemDelegate(QtData.__QtEditor(parent=self))
     
    		# La zone de datas
    		self.__tableData=QTableWidget(0, 0, parent=self)
    		self.__tableData.setColumnCount(len(data[0]))
    		self.__tableData.setSortingEnabled(True)
     
    		# Positionnement principal
    		mainLayout=QVBoxLayout(self)
    		mainLayout.setSpacing(0)
    		mainLayout.setContentsMargins(0, 0, 0, 0)
    		mainLayout.addWidget(self.__tableChoice, 0)
    		mainLayout.addWidget(self.__tableData, 1)
     
    		# Remplissage QTableWidget
    		self.__loadData(data)
    	# __init__()
     
    	# Remplissage table
    	def __loadData(self, data):
    		# Le tableau est initialisé
    		self.__tableData.blockSignals(True)
    		self.__tableData.clearContents()
     
    		# Remplissage
    		for (row, d) in enumerate(data):
    			for (col, value) in enumerate(d):
    				item=QTableWidgetItem(str(value))
    				item.setData(Qt.UserRole, str(value))
    				self.__tableData.setRowCount(row+1)
    				self.__tableData.setItem(row, col, item)
    			# for
    		# for
    		self.__tableData.blockSignals(False)
     
    		# Chargement zone de recherche (qui récupèrera les données du tableau)
    		self.__prepareRecherche()
    	# __loadData()
     
    	# Chargement zone de recherche
    	def __prepareRecherche(self):
    		# Création des valeurs associées à chaque colonne de la zone de recherche
    		values=tuple(set() for i in range(self.__tableChoice.columnCount()))
    		for row in range(self.__tableData.rowCount()):
    			for col in range(self.__tableData.columnCount()):
    				values[col].add(self.__tableData.item(row, col).data(Qt.DisplayRole))
     
    		# Remplissage des données de la table des choix
    		self.__tableChoice.blockSignals(True)
    		self.__tableChoice.clearContents()
    		for (col, v) in enumerate(values):
    			item=QTableWidgetItem()
    			item.setData(
    				Qt.UserRole,
    				{"values" : tuple(sorted(v)), "find" : None, "idx" : 0},
    			)
    			self.__tableChoice.setItem(0, col, item)
    		# for
    		self.__tableChoice.blockSignals(False)
    	# __prepareRecherche()
     
    	# Slot filtre
    	def __slotFiltre(self, *args, **kwargs):
    		# Balayage des lignes
    		for row in range(self.__tableData.rowCount()):
    			# Balayage des colonnes
    			for col in range(self.__tableData.columnCount()):
    				# Récupération item cherché
    				find=self.__tableChoice.item(0, col).data(Qt.UserRole)["find"]
     
    				# Si l'item ne correspond pas
    				if find is not None and self.__tableData.item(row, col).data(Qt.UserRole) != find:
    					# On cache la ligne et on arrête
    					self.__tableData.hideRow(row)
    					break
    				# if
    			else: # Si pas trouvé de "non correspondance"
    				# On affiche la ligne
    				self.__tableData.showRow(row)
    			# for
    		# for
    	# __slotFiltre
     
    	# Editeur associé au tableWidget
    	class __QtEditor(QItemDelegate):
    		# Création de l'éditeur (méthode surchargée)
    		def createEditor(self, parent, option, index):
    			# Si on n'est pas sur ligne 0 (sécurité)
    			if index.row() != 0:
    				# Aucun éditeur
    				return None
     
    			# Création d'un menu déroulant
    			return QComboBox(parent=parent)
    		# createEditor()
     
    		# Positionne valeur dans zone d'édition
    		def setEditorData(self, editor, index):
    			# S'il n'y a pas d'éditeur
    			if editor is None: return
     
    			# Récupération informations associées à colonne
    			indexRef=index.sibling(0, index.column())
    			data=indexRef.model().data(indexRef, Qt.UserRole)
     
    			# Remplissage du menu déroulant (avec une valeur nulle pour annuler la recherche)
    			for d in (None,) + data["values"]:
    				editor.addItem("[%s]" % d if d is not None else "", d)
    			editor.setCurrentIndex(data["idx"])
    		# setEditorData()
     
    		# Enregistre valeur dans modèle
    		def setModelData(self, editor, model, index):
    			# S'il n'y a pas d'éditeur, inutile de continuer
    			if editor is None: return
     
    			# Récupération informations associées à colonne
    			indexRef=index.sibling(0, index.column())
    			data=indexRef.model().data(indexRef, Qt.UserRole)
     
    			# Enregistrement choix utilisateur dans modèle
    			idx=editor.currentIndex()
    			val=editor.itemData(idx)
    			indexRef.model().setData(
    				indexRef,
    				{"values" : data["values"], "find" : val, "idx" : idx},
    				Qt.UserRole,
    			)
     
    			# Réaffichage menu déroulant
    			indexRef.model().setData(
    				indexRef,
    				"[%s]" % val if val is not None else "",
    				Qt.DisplayRole,
    			)
    		# setModelData()
    	# class __QtEditor
    # class QtData
     
    # Programme principal
    if __name__ == "__main__":
    	import random
    	app=QApplication(sys.argv)
    	fen=QtData([[random.randint(1, 10) for i in range(5)] for j in range(10)])
    	fen.show()
    	sys.exit(app.exec_())
    # if
    Et si tu préfères Qt6 ou Side6 tu me dis
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  4. #4
    Expert confirmé
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    4 060
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 4 060
    Par défaut
    T'as essayé de mettre toutes les valeurs de

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    mainLayout.setContentsMargins(10, 10, 10, 10)
    à 0 ?

    J'ai pas pu tester, fait un copier coller de ton code que tu partages et tu y verras des erreurs du type IndentationError: unindent does not match any outer indentation level

  5. #5
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par fred1599 Voir le message
    T'as essayé de mettre toutes les valeurs de

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    mainLayout.setContentsMargins(10, 10, 10, 10)
    à 0 ?
    Ca ce sont les espacements autour du layout (NSEO). Ca n'entre pas en jeu pour les widgets qui sont dans le layout (qui, eux, sont gérés par le setSpacing).
    Ce qui ne m'empêche pas d'essyer mais ça n'a rien changé.

    Citation Envoyé par fred1599 Voir le message
    J'ai pas pu tester, fait un copier coller de ton code que tu partages et tu y verras des erreurs du type IndentationError: unindent does not match any outer indentation level
    Oui, bizarre. En fait c'est le @pyqtSlot qui est mal géré par le fofo. Dans mon code c'est bon, quand je le copie ici c'est bon, si je le récupère depuis mon post en mode "édition" il reste bon mais si je le récupère via copier/coller depuis le forum (comme tu le fais) cette ligne part en couille.
    Elle est facultative donc tu peux l'enlever. Je l'ai aussi supprimée de mon post précédent (j'ai testé le code en copier/coller ça marche).
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  6. #6
    Expert confirmé
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    4 060
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 4 060
    Par défaut
    C'est mieux,

    Quelque chose comme cela conviendrait mieux ?



    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #!/usr/bin/env python
    # coding: utf-8
     
    from PyQt5.QtWidgets import *
    from PyQt5.QtCore import *
    import sys
     
    class QtData(QWidget):
        def __init__(self, data, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.resize(600, 300)
     
            # La zone de sélection
            self.__tableChoice=QTableWidget(0, 0, parent=self, itemChanged=self.__slotFiltre)
            self.__tableChoice.setRowCount(1)
            self.__tableChoice.setColumnCount(len(data[0]))
     
            # L'éditeur de la zone de sélection
            self.__tableChoice.setItemDelegate(QtData.__QtEditor(parent=self))
     
            # La zone de datas
            self.__tableData=QTableWidget(0, 0, parent=self)
            self.__tableData.setColumnCount(len(data[0]))
            self.__tableData.setSortingEnabled(True)
     
            # Positionnement principal avec correction de l'espace inutile
            mainLayout=QVBoxLayout(self)
            mainLayout.setSpacing(0)
            mainLayout.setContentsMargins(0, 0, 0, 0)
     
            # Ajustement de la taille de la première table
            self.__tableChoice.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
            self.__tableChoice.setMaximumHeight(self.__tableChoice.verticalHeader().sectionSize(0) + self.__tableChoice.horizontalHeader().height())
     
            # Ajout des tables avec gestion du stretch
            mainLayout.addWidget(self.__tableChoice)
            mainLayout.addWidget(self.__tableData, 1)
     
            # Remplissage QTableWidget
            self.__loadData(data)
        # __init__()
     
        # Remplissage table
        def __loadData(self, data):
            # Le tableau est initialisé
            self.__tableData.blockSignals(True)
            self.__tableData.clearContents()
     
            # Remplissage
            for (row, d) in enumerate(data):
                for (col, value) in enumerate(d):
                    item=QTableWidgetItem(str(value))
                    item.setData(Qt.UserRole, str(value))
                    self.__tableData.setRowCount(row+1)
                    self.__tableData.setItem(row, col, item)
                # for
            # for
            self.__tableData.blockSignals(False)
     
            # Chargement zone de recherche (qui récupèrera les données du tableau)
            self.__prepareRecherche()
        # __loadData()
     
        # Chargement zone de recherche
        def __prepareRecherche(self):
            # Création des valeurs associées à chaque colonne de la zone de recherche
            values=tuple(set() for i in range(self.__tableChoice.columnCount()))
            for row in range(self.__tableData.rowCount()):
                for col in range(self.__tableData.columnCount()):
                    values[col].add(self.__tableData.item(row, col).data(Qt.DisplayRole))
     
            # Remplissage des données de la table des choix
            self.__tableChoice.blockSignals(True)
            self.__tableChoice.clearContents()
            for (col, v) in enumerate(values):
                item=QTableWidgetItem()
                item.setData(
                    Qt.UserRole,
                    {"values" : tuple(sorted(v)), "find" : None, "idx" : 0},
                )
                self.__tableChoice.setItem(0, col, item)
            # for
            self.__tableChoice.blockSignals(False)
        # __prepareRecherche()
     
        # Slot filtre
        def __slotFiltre(self, *args, **kwargs):
            # Balayage des lignes
            for row in range(self.__tableData.rowCount()):
                # Balayage des colonnes
                for col in range(self.__tableData.columnCount()):
                    # Récupération item cherché
                    find=self.__tableChoice.item(0, col).data(Qt.UserRole)["find"]
     
                    # Si l'item ne correspond pas
                    if find is not None and self.__tableData.item(row, col).data(Qt.UserRole) != find:
                        # On cache la ligne et on arrête
                        self.__tableData.hideRow(row)
                        break
                    # if
                else: # Si pas trouvé de "non correspondance"
                    # On affiche la ligne
                    self.__tableData.showRow(row)
                # for
            # for
        # __slotFiltre
     
        # Editeur associé au tableWidget
        class __QtEditor(QItemDelegate):
            # Création de l'éditeur (méthode surchargée)
            def createEditor(self, parent, option, index):
                # Si on n'est pas sur ligne 0 (sécurité)
                if index.row() != 0:
                    # Aucun éditeur
                    return None
     
                # Création d'un menu déroulant
                return QComboBox(parent=parent)
            # createEditor()
     
            # Positionne valeur dans zone d'édition
            def setEditorData(self, editor, index):
                # S'il n'y a pas d'éditeur
                if editor is None: return
     
                # Obtenir la largeur de la colonne et ajuster celle du QComboBox
                editor.setMinimumWidth(index.model().index(0, index.column()).tableWidget().columnWidth(index.column()))
     
                # Récupération informations associées à colonne
                indexRef=index.sibling(0, index.column())
                data=indexRef.model().data(indexRef, Qt.UserRole)
     
                # Remplissage du menu déroulant (avec une valeur nulle pour annuler la recherche)
                for d in (None,) + data["values"]:
                    editor.addItem("[%s]" % d if d is not None else "", d)
                editor.setCurrentIndex(data["idx"])
            # setEditorData()
     
            # Enregistre valeur dans modèle
            def setModelData(self, editor, model, index):
                # S'il n'y a pas d'éditeur, inutile de continuer
                if editor is None: return
     
                # Récupération informations associées à colonne
                indexRef=index.sibling(0, index.column())
                data=indexRef.model().data(indexRef, Qt.UserRole)
     
                # Enregistrement choix utilisateur dans modèle
                idx=editor.currentIndex()
                val=editor.itemData(idx)
                indexRef.model().setData(
                    indexRef,
                    {"values" : data["values"], "find" : val, "idx" : idx},
                    Qt.UserRole,
                )
     
                # Réaffichage menu déroulant
                indexRef.model().setData(
                    indexRef,
                    "[%s]" % val if val is not None else "",
                    Qt.DisplayRole,
                )
            # setModelData()
        # class __QtEditor
    # class QtData
     
    # Programme principal
    if __name__ == "__main__":
        import random
        app=QApplication(sys.argv)
        fen=QtData([[random.randint(1, 10) for i in range(5)] for j in range(10)])
        fen.show()
        sys.exit(app.exec_())
    # if
    Images attachées Images attachées  

  7. #7
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par fred1599 Voir le message
    Quelque chose comme cela conviendrait mieux ?
    Ah oui nickel

    Bien entendu j'ai examiné ton code (tu n'en attendais certainement pas moins). J'ai bien pigé le fait que tu définisses la hauteur maximale du tableau à la hauteur du titre + la hauteur d'une ligne (le verticalHeader().sectionSize(0)). En rajoutant un "+5" c'est encore mieux mais c'est dommage que le tableWidget ne s'adapte pas tout seul à sa propre taille et qu'il faille le lui dire explicitement.
    Il me semble d'après la doc que puisque le tableWidget est géré par le layout, le setSizePolicy() n'est pas nécessaire (j'ai tenté sans et ça fait pareil).

    Super merci de tes excellents conseils et de m'avoir fait partager tes connaissances Qt qui me manquaient.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  8. #8
    Expert confirmé
    Avatar de fred1599
    Homme Profil pro
    Lead Dev Python
    Inscrit en
    Juillet 2006
    Messages
    4 060
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Lead Dev Python
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Juillet 2006
    Messages : 4 060
    Par défaut
    En utilisant setFixedHeight, la ligne de filtrage s'affiche de manière compacte.

    Les colonnes sont redimensionnées automatiquement avec ResizeToContents, ça assure que leur largeur correspond bien au contenu.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #!/usr/bin/env python
    # coding: utf-8
     
    from PyQt5.QtWidgets import *
    from PyQt5.QtCore import *
    import sys
     
    class QtData(QWidget):
        def __init__(self, data, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.resize(600, 300)
     
            # La zone de sélection
            self.__tableChoice=QTableWidget(0, 0, parent=self, itemChanged=self.__slotFiltre)
            self.__tableChoice.setRowCount(1)
            self.__tableChoice.setColumnCount(len(data[0]))
     
            # L'éditeur de la zone de sélection
            self.__tableChoice.setItemDelegate(QtData.__QtEditor(parent=self))
     
            # La zone de datas
            self.__tableData=QTableWidget(0, 0, parent=self)
            self.__tableData.setColumnCount(len(data[0]))
            self.__tableData.setSortingEnabled(True)
     
            # Positionnement principal
            mainLayout=QVBoxLayout(self)
            mainLayout.setSpacing(0)
            mainLayout.setContentsMargins(0, 0, 0, 0)
     
            # Ajustement automatique de la largeur des colonnes seulement
            self.__tableChoice.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
     
            # Fixer manuellement la hauteur pour n'avoir qu'une seule ligne dans la table de sélection
            self.__tableChoice.setFixedHeight(self.__tableChoice.verticalHeader().sectionSize(0) + self.__tableChoice.horizontalHeader().height())
     
            # Ajout des tables
            mainLayout.addWidget(self.__tableChoice)
            mainLayout.addWidget(self.__tableData, 1)
     
            # Remplissage QTableWidget
            self.__loadData(data)
        # __init__()
     
        # Remplissage table
        def __loadData(self, data):
            # Le tableau est initialisé
            self.__tableData.blockSignals(True)
            self.__tableData.clearContents()
     
            # Remplissage
            for (row, d) in enumerate(data):
                for (col, value) in enumerate(d):
                    item=QTableWidgetItem(str(value))
                    item.setData(Qt.UserRole, str(value))
                    self.__tableData.setRowCount(row+1)
                    self.__tableData.setItem(row, col, item)
                # for
            # for
            self.__tableData.blockSignals(False)
     
            # Chargement zone de recherche (qui récupèrera les données du tableau)
            self.__prepareRecherche()
        # __loadData()
     
        # Chargement zone de recherche
        def __prepareRecherche(self):
            # Création des valeurs associées à chaque colonne de la zone de recherche
            values=tuple(set() for i in range(self.__tableChoice.columnCount()))
            for row in range(self.__tableData.rowCount()):
                for col in range(self.__tableData.columnCount()):
                    values[col].add(self.__tableData.item(row, col).data(Qt.DisplayRole))
     
            # Remplissage des données de la table des choix
            self.__tableChoice.blockSignals(True)
            self.__tableChoice.clearContents()
            for (col, v) in enumerate(values):
                item=QTableWidgetItem()
                item.setData(
                    Qt.UserRole,
                    {"values" : tuple(sorted(v)), "find" : None, "idx" : 0},
                )
                self.__tableChoice.setItem(0, col, item)
            # for
            self.__tableChoice.blockSignals(False)
        # __prepareRecherche()
     
        # Slot filtre
        def __slotFiltre(self, *args, **kwargs):
            # Balayage des lignes
            for row in range(self.__tableData.rowCount()):
                # Balayage des colonnes
                for col in range(self.__tableData.columnCount()):
                    # Récupération item cherché
                    find=self.__tableChoice.item(0, col).data(Qt.UserRole)["find"]
     
                    # Si l'item ne correspond pas
                    if find is not None and self.__tableData.item(row, col).data(Qt.UserRole) != find:
                        # On cache la ligne et on arrête
                        self.__tableData.hideRow(row)
                        break
                    # if
                else: # Si pas trouvé de "non correspondance"
                    # On affiche la ligne
                    self.__tableData.showRow(row)
                # for
            # for
        # __slotFiltre
     
        # Editeur associé au tableWidget
        class __QtEditor(QItemDelegate):
            # Création de l'éditeur (méthode surchargée)
            def createEditor(self, parent, option, index):
                # Si on n'est pas sur ligne 0 (sécurité)
                if index.row() != 0:
                    # Aucun éditeur
                    return None
     
                # Création d'un menu déroulant
                return QComboBox(parent=parent)
            # createEditor()
     
            # Positionne valeur dans zone d'édition
            def setEditorData(self, editor, index):
                # S'il n'y a pas d'éditeur
                if editor is None: return
     
                # Obtenir la largeur de la colonne et ajuster celle du QComboBox
                editor.setMinimumWidth(index.model().index(0, index.column()).tableWidget().columnWidth(index.column()))
     
                # Récupération informations associées à colonne
                indexRef=index.sibling(0, index.column())
                data=indexRef.model().data(indexRef, Qt.UserRole)
     
                # Remplissage du menu déroulant (avec une valeur nulle pour annuler la recherche)
                for d in (None,) + data["values"]:
                    editor.addItem("[%s]" % d if d is not None else "", d)
                editor.setCurrentIndex(data["idx"])
            # setEditorData()
     
            # Enregistre valeur dans modèle
            def setModelData(self, editor, model, index):
                # S'il n'y a pas d'éditeur, inutile de continuer
                if editor is None: return
     
                # Récupération informations associées à colonne
                indexRef=index.sibling(0, index.column())
                data=indexRef.model().data(indexRef, Qt.UserRole)
     
                # Enregistrement choix utilisateur dans modèle
                idx=editor.currentIndex()
                val=editor.itemData(idx)
                indexRef.model().setData(
                    indexRef,
                    {"values" : data["values"], "find" : val, "idx" : idx},
                    Qt.UserRole,
                )
     
                # Réaffichage menu déroulant
                indexRef.model().setData(
                    indexRef,
                    "[%s]" % val if val is not None else "",
                    Qt.DisplayRole,
                )
            # setModelData()
        # class __QtEditor
    # class QtData
     
    # Programme principal
    if __name__ == "__main__":
        import random
        app=QApplication(sys.argv)
        fen=QtData([[random.randint(1, 10) for i in range(5)] for j in range(10)])
        fen.show()
        sys.exit(app.exec_())
    # if

  9. #9
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Oups ce nouveau code a des défaillances et régresse.
    Déjà le self.__tableChoice.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents) amène la zone de choix à être collée à gauche. Et avec mon vrai programme (celui qui traite des données CSV) la colonne du menu déroulant devient trop large par rapport à la zone de données.
    Je pense que Stretch conviendrait mieux. Ce qui m'amène à rajouter aussi self.__tableChoice.verticalHeader().setSectionResizeMode(QHeaderView.Fixed).
    Et le editor.setMinimumWidth(index.model().index(0, index.column()).tableWidget().columnWidth(index.column())) ne va pas car index.model() renvoie un QModelIndex qui n'a pas d'attribut "tableWidget". Je vois bien l'idée (adapter la taille de la combo à la taille de la colonne) mais en fait c'est déjà quasiment le cas par défaut (il y a quelques écarts minimes selon la donnée du menu et le fait que la zone de data affiche ou n'affiche pas l'ascenseur du scroll intégré) mais ça reste minime.

    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #!/usr/bin/env python
    # coding: utf-8
     
    from PyQt5.QtWidgets import *
    from PyQt5.QtCore import *
    import sys
     
    class QtData(QWidget):
    	def __init__(self, data, *args, **kwargs):
    		super().__init__(*args, **kwargs)
    		self.resize(600, 300)
     
    		# La table des choix
    		self.__tableChoice=QTableWidget(0, 0, parent=self)
    		self.__tableChoice.setRowCount(1)
    		self.__tableChoice.setColumnCount(len(data[0]))
    		self.__tableChoice.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
    		self.__tableChoice.verticalHeader().setSectionResizeMode(QHeaderView.Fixed)
    		self.__tableChoice.setMaximumHeight(
    			self.__tableChoice.verticalHeader().sectionSize(0)\
    			+ self.__tableChoice.horizontalHeader().height()
    		)
    		for col in range(self.__tableChoice.columnCount()):
    			self.__tableChoice.setItem(0, col, QTableWidgetItem())
    		self.__tableChoice.itemChanged[QTableWidgetItem].connect(self.__slotFiltre)
     
    		# L'éditeur de la zone de sélection
    		self.__tableChoice.setItemDelegate(QtData.__QtEditor(parent=self))
     
    		# La zone de datas
    		self.__tableData=QTableWidget(0, 0, parent=self)
    		self.__tableData.setColumnCount(len(data[0]))
    		#self.__tableData.horizontalHeader().hide()
    		self.__tableData.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
     
    		# Positionnement principal
    		mainLayout=QVBoxLayout(self)
    		mainLayout.setSpacing(0)
    		mainLayout.setContentsMargins(0, 0, 0, 0)
     		mainLayout.addWidget(self.__tableChoice, stretch=0)
    		mainLayout.addWidget(self.__tableData, stretch=1)
     
    		# Remplissage QTableWidget
    		self.__loadData(data)
    	# __init__()
     
    	# Remplissage table
    	def __loadData(self, data):
    		# Le tableau est initialisé
    		self.__tableData.blockSignals(True)
    		self.__tableData.clearContents()
    		self.__tableData.setRowCount(0)
     
    		# Remplissage
    		for (row, d) in enumerate(data):
    			self.__tableData.insertRow(row)
    			for (col, value) in enumerate(d):
    				item=QTableWidgetItem(str(value))
    				item.setFlags(item.flags()^Qt.ItemIsEditable) # ReadOnly
    				item.setData(Qt.UserRole, str(value))
    				self.__tableData.setItem(row, col, item)
    			# for
    		# for
    		self.__tableData.blockSignals(False)
     
    		# Chargement zone de recherche (qui récupèrera les données du tableau)
    		self.__prepareRecherche()
    	# __loadData()
     
    	# Chargement zone de recherche
    	def __prepareRecherche(self):
    		# Création des valeurs associées à chaque colonne de la zone de recherche
    		values=tuple(set() for i in range(self.__tableChoice.columnCount()))
    		for row in range(self.__tableData.rowCount()):
    			for col in range(self.__tableData.columnCount()):
    				values[col].add(self.__tableData.item(row, col).data(Qt.DisplayRole))
     
    		# Remplissage des données de la table des choix
    		self.__tableChoice.blockSignals(True)
    		self.__tableChoice.clearContents()
    		for (col, v) in enumerate(values):
    			item=QTableWidgetItem()
    			item.setData(
    				Qt.UserRole,
    				{"values" : tuple(sorted(v)), "find" : None},
    			)
    			self.__tableChoice.setItem(0, col, item)
    		# for
    		self.__tableChoice.blockSignals(False)
    	# __prepareRecherche()
     
    	# Slot filtre
    	def __slotFiltre(self, *args, **kwargs):
    		# Balayage des lignes
    		for row in range(self.__tableData.rowCount()):
    			# Balayage des colonnes
    			for col in range(self.__tableData.columnCount()):
    				# Récupération item cherché
    				find=self.__tableChoice.item(0, col).data(Qt.UserRole)["find"]
     
    				# Si l'item ne correspond pas
    				if find is not None and self.__tableData.item(row, col).data(Qt.UserRole) != find:
    					# On cache la ligne et on arrête
    					self.__tableData.hideRow(row)
    					break
    				# if
    			else: # Si pas trouvé de "non correspondance"
    				# On affiche la ligne
    				self.__tableData.showRow(row)
    			# for
    		# for
    	# __slotFiltre
     
    	# Editeur associé au tableWidget
    	class __QtEditor(QItemDelegate):
    		# Création de l'éditeur (méthode surchargée)
    		def createEditor(self, parent, option, index):
    			# Si on n'est pas sur ligne 0 (sécurité)
    			if index.row() != 0:
    				# Aucun éditeur
    				return None
     
    			# Récupération informations associées à colonne
    			indexRef=index.sibling(0, index.column())
    			data=indexRef.model().data(
    				indexRef,
    				Qt.UserRole,
    			)
     
    			# Création d'un menu déroulant et remplissage (avec une valeur neutre en plus)
    			editor=QComboBox(parent=parent)
    			for d in (None,) + tuple(data["values"]):
    				editor.addItem("[%s]" % d if d is not None else "", d)
     
    			# L'éditeur est créé
    			return editor
    		# createEditor()
     
    		# Enregistre valeur dans modèle
    		def setModelData(self, editor, model, index):
    			# S'il n'y a pas d'éditeur, inutile de continuer
    			if editor is None: return
     
    			# Récupération informations associées à colonne
    			indexRef=index.sibling(0, index.column())
    			model=indexRef.model()
    			data=model.data(indexRef, Qt.UserRole)
     
    			# Enregistrement choix utilisateur dans modèle
    			val=editor.itemData(editor.currentIndex())
    			model.setData(
    				indexRef,
    				{"values" : data["values"], "find" : val},
    				Qt.UserRole,
    			)
     
    			# Réaffichage menu déroulant
    			model.setData(
    				indexRef,
    				"[%s]" % val if val is not None else "",
    				Qt.DisplayRole,
    			)
    		# setModelData()
    	# class __QtEditor
    # class QtData
     
    # Programme principal
    if __name__ == "__main__":
    	import random
    	app=QApplication(sys.argv)
    	fen=QtData([[random.randint(1, 10) for i in range(5)] for j in range(10)])
    	fen.show()
    	sys.exit(app.exec_())
    # if
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  10. #10
    Expert confirmé Avatar de papajoker
    Homme Profil pro
    Développeur Web
    Inscrit en
    Septembre 2013
    Messages
    2 323
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nièvre (Bourgogne)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Septembre 2013
    Messages : 2 323
    Par défaut
    bonjour

    Désolé, j'arrive après la bataille

    Ton code est clairement ce que je trouve être du code spagetti (__loadData, __prepareRecherche = pas compréhensible pour moi), j'ai donc tout réécrit (sauf imports python) avec un modèle :
    - plus générique (réutilisation sans problème d'une ou des classes pour tout autre projet, et donc beaucoup plus de maintenabilité)
    - code métier est maintenant dans les modèles, en particulier les filtres. voir MainProxyModel. Bien sûr, à réécrire en fonction des besoins.
    - plus rapide ? moins de code python interprété aux filtres contre plus de code compilé du framework utilisé

    Problèmes actuels:
    - 1 : l'ajout d'une ligne vide dans le combo, ici j'ai (mal) triché en insérant cette ligne au début des datas ...
    - 2 : update du déplacement des widgets filtres un peu simple, la mise à jour est faite sur un événement paint (pas optimal en performance)

    Ajouts non demandés (uniquement) pour tests :
    - mode édition ON : pour voir que les filtres sont mis à jour automatiquement
    - resize de la colonne 1 à la souris, pour voir si les filtres sont bien positionnés.
    - n'utilise pas que des combos pour filtre (comme demandé) : pour être plus générique (editeur avec autocomplétion) et permet un spectre plus large (combo == valeur unique)
    EDIT un exemple de combo qui utilise les 2 modes utilité ???

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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
    #!/usr/bin/env python
     
    import sys
    from PyQt6.QtWidgets import *
    from PyQt6.QtCore import *
    from PyQt6.QtGui import *
     
    class MainModel(QAbstractTableModel):
        # 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 (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole):
                return self._data[index.row()][index.column()]
            if role == Qt.ItemDataRole.UserRole + 1:
                return self._head[index.column()]
     
        def headerData(self, section: int, orientation: Qt.Orientation, role: int = ...):
            if role != Qt.ItemDataRole.DisplayRole:
                return None
            if orientation == Qt.Orientation.Horizontal:
                return self._head[section].capitalize()
                #return chr(section + ord("A"))
            if orientation == Qt.Orientation.Vertical:
                return f"{section}"
     
        def flags(self, index):
            # rendre éditable ... pour test si contenu des combos changent
            return Qt.ItemFlag.ItemNeverHasChildren | Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsEditable | Qt.ItemFlag.ItemIsSelectable
        def setData(self, index, value, role=Qt.ItemDataRole.EditRole):
            """ici pour test si contenu des combos changent"""
            if index.isValid() and role == Qt.ItemDataRole.EditRole:
                self._data[index.row()][index.column()] = value
                self.dataChanged.emit(index, index, {role})
                return True
            return False
     
    class MainProxyModel(QSortFilterProxyModel):
        """
            filtre(s) particulier à un métier
        """
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.filters = {} # 1 filtre par colonne
     
        def setFilterByColumn(self, regex: str, column: int):
            if regex != "":
                self.filters[column] = regex.lower()
            else:
                del self.filters[column]
            self.invalidateFilter()
            print("filtres:", self.filters)
     
        def filterAcceptsRow(self, source_row, source_parent):
            """filtre "manuel" sur plusieurs colonnes"""
            for column, regex in self.filters.items():
                if regex == "":
                    break
                index = self.sourceModel().index(source_row, column, source_parent)
                if not index.isValid():
                    return False
                if text := str(self.sourceModel().data(index, Qt.ItemDataRole.DisplayRole)):
                    if regex not in text.lower():
                        return False
            return True
     
     
    class ToolProxyModel(QSortFilterProxyModel):
        """utilitaire pour remplir petits widgets (combo, autocompletion, ...)"""
     
        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(Qt.CaseSensitivity.CaseInsensitive)
            self.column = column
            self.setDynamicSortFilter(True)
     
        def columnCount(self, parent=...) -> int:
            return 1
     
        def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
            index = self.sourceModel().index(source_row, self.column, source_parent)
            data = str(self.sourceModel().data(index, 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: 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 FilterTable(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 = QTableView()
            self.table.setModel(self.filterModel)
            self.table.hideRow(0)   # pas beau : pour la combobox
            if header := self.table.horizontalHeader():
                header.setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
                header.setSectionResizeMode(0, QHeaderView.ResizeMode.Interactive)
                header.setStretchLastSection(True)
     
            mainLayout=QVBoxLayout(self)
            mainLayout.setSpacing(0)
            mainLayout.setContentsMargins(0, 0, 0, 0)
            mainLayout.addLayout(self.initTools())
            mainLayout.addWidget(self.table)
     
        def initTools(self):
            tools=QHBoxLayout()
            tools.setContentsMargins(20, 0, 0, 0)
            for i in range(self.model.columnCount(0)):
                # liaison des widgets à la BD
                title = self.model.data(self.model.index(0, i), Qt.ItemDataRole.UserRole + 1)
                print(i, title)
                tool = QComboBox() if i ==0 else QLineEdit()
                self.filters.append(tool)
                tool.setToolTip(title)
                tool.setPlaceholderText("filtre")
                tools.addWidget(tool)
                if isinstance(tool, QLineEdit):
                    completer = QCompleter()
                    modelproxy = ToolProxyModel(column=i, duplicate=False)
                    modelproxy.setSourceModel(self.model)
                    completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
                    completer.setModel(modelproxy)
                    tool.setCompleter(completer)
                    tool.textChanged.connect(self.onFiltrerChange)
                else:
                    modelproxy = ToolProxyModel(column=0, duplicate=False, miniLong=0)
                    modelproxy.setSourceModel(self.model)
                    tool.setModel(modelproxy)
                    tool.setCurrentIndex(-1)
                    tool.currentTextChanged.connect(self.onFiltrerChange)
     
            self.table.horizontalHeader().viewport().installEventFilter(self)  # pour ajuster les tailles... voir eventFilter()
            self.tools = tools
            return tools
     
        def onFiltrerChange(self, data):
            """Appliquer un/des filtre(s) à la grille"""
            sender = self.sender()
            col = 0
            if  isinstance(sender, QComboBox) and data == "":
                self.filters[0].setCurrentIndex(-1)
            elif isinstance(sender, QLineEdit) and isinstance(sender.completer().model(), ToolProxyModel):
                col = sender.completer().model().column
            print("filtre:", sender, col, data)
            self.table.model().setFilterByColumn(data, col)
     
        def eventFilter(self, obj, event):
            """ intercepter les tailles , puis forcer celles des filtres """
            if  isinstance(event, QResizeEvent) or isinstance(event, 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(QMainWindow):
        def __init__(self, datas):
            super().__init__()
            model = MainModel(datas, ("mois", "Ville", "vente"))
            self.resize(620, 380)
            self.statusBar()        
            self.table = FilterTable(model)
            self.setCentralWidget(self.table)
     
     
     
    if __name__ == "__main__":
     
        data = (
            ("", "", ""),
            ["Janvier", "Rennes", 150],
            ["Février", "Paris", 35],
            ["Mars", "Marseilles", 120_000],
            ["Avril", "Paris", 130],
            ["Mai", "Marseilles", 25],
            ["Juin", "Rennes", 120_000],
            ["Juillet", "Rennes sur mer", 120_100],
        )
     
        app=QApplication(sys.argv)
        win = MainWindow(data)
        win.show()
        sys.exit(app.exec())

  11. #11
    Membre prolifique
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 830
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 830
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par papajoker Voir le message
    Ton code est clairement ce que je trouve être du code spagetti (__loadData, __prepareRecherche = pas compréhensible pour moi), j'ai donc tout réécrit (sauf imports python) avec un modèle :
    C'est vrai que ton résultat a énormément de classe !!!
    Je ne peux que m'incliner devant cette maitrise des modèles Qt que je suis loin de posséder.

    Après ton "code spaghetti" est peut-être un peu exagéré. Il est normal de charger les données et de dédier ce chargement à une fonction qui s'occupera de ce travail. Ainsi si les données changent, on rappelle la fonction. De même il semble normal, une fois les données chargées, de préparer la zone de recherches qui dépend des données chargées. Donc là encore une fonction pour ça me semble approprié. Oui puisque la préparation va avec les données j'aurais pu intégrer cette préparation dans la fonction de chargement mais c'était dans le cas où demain les deux actions seraient, pour une raison X ou Y, décorrélées.
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  12. #12
    Expert confirmé Avatar de papajoker
    Homme Profil pro
    Développeur Web
    Inscrit en
    Septembre 2013
    Messages
    2 323
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nièvre (Bourgogne)

    Informations professionnelles :
    Activité : Développeur Web
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : Septembre 2013
    Messages : 2 323
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    Après ton "code spaghetti" est peut-être un peu exagéré.
    Oui C'est surtout que ici, tu fais un code "perso" pour une fonctionnalité présente dans le framework :
    modele -> vue# toi tu modifies le modèle (model().setData(...)) et tu fais un hideRow() showRow() en fonction de ce que tu as modifié. Il ne faut en aucun cas avoir un autre système qui lui aussi va modifier le modèle () donc c'est une technique à n'utiliser qu'une seule fois !

    Framawork qt :
    modele -> proxy -> vue # on ne fait que des liaisons puis, on travaille que sur le proxy (pour répondre au besoin "métier")
    Existe un modèle pour faire des filtres, on change le comportement du proxy et la vue s'adapte automatiquement. Avantage, la vue n'est pas forcément un tableau, peut être un TreeView, combo, ... Et en vitesse : ici c'est le moteur Qt compilé qui travaille.

    Image un peu grosse: Tu ignores que List à une méthodologie intégrée pour trier, tu écris la tienne, mais elle n'est pas applicable dans tous les cas ...

    Citation Envoyé par Sve@r Voir le message
    mais c'était dans le cas où demain les deux actions seraient ...
    Et justement, avec proxy (voir IdentityModel), le code ne va pratiquement pas changer quel que soit ce qui est demandé en plus demain.

    Exemple plus concret : un manager qui surveille ces vendeurs
    ici, pour démo, on a en plus un filtre "métier" : +100 == plus de 100 ventes, -100 == moins de 100 ventes

    Note:
    - par rapport au premier code, pour plus de simplicité d'utilisation, j'ai créé un widget Filtre(lineEdit)
    - le filtre est optionnel (ici, rien sur "secteur") # parfois cela n'a pas de sens sur une colonne particulière
    - Ici, je peux rajouter une autre vue (camembert dans exemple) liée au filtres (proxyTableau -> graphiqueVue donc aucun code particulier) # Comment faire avec ton code ??? Je commence a avoir mal à la tête

    Nom : a-Copie-d-cran-20241007-195922.png
Affichages : 174
Taille : 26,8 Ko

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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())

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [CR] Filtrer pour une période donnée
    Par liberio dans le forum SAP Crystal Reports
    Réponses: 6
    Dernier message: 21/04/2004, 16h32
  2. [JTextField] filtrer la saisie
    Par Merfolk dans le forum Composants
    Réponses: 7
    Dernier message: 04/03/2004, 19h57
  3. Filtrer les voyelles
    Par Babyneedle dans le forum Langage SQL
    Réponses: 9
    Dernier message: 22/12/2003, 15h12
  4. peut on filtrer les adresses IP ?
    Par travail dans le forum 4D
    Réponses: 2
    Dernier message: 04/06/2003, 14h16
  5. [VBA-E] [Excel] Filtrer le donnees d'une sheet
    Par donia dans le forum Macros et VBA Excel
    Réponses: 6
    Dernier message: 27/09/2002, 10h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo