Discussion :

[aurelie.guegan.15]

Bonjour à tous,

J'ai actuellement un soucie non résolu depuis un moment que j'avais laissé de côté. j'espère que cela vous parlera.

Le principe:
Un QlineEdit pour faire une recherche.
Un QtableWidget avec deux colonnes : colonne 0 des noms ou descriptions et colonne 1 le code correspondant. Le tableau est remplis via une base de données comprenant plus de 3000 lignes.
L'utilisateur peut :
1)Rechercher via le QlineEdit soit un nom, soit un code dans ce tableau. Comme résultat de la recherche,je n'affiche que les lignes où se trouve les caractères entré par l'utilisateur dans ce même tableau.
2)Double cliquer sur le nom ou le code souhaité et la fenêtre se ferme.

Mon problème :

Lors que je fait une recherche les colonnes et les lignes ne s'affichent pas comme je le souhaiterais. C'est à dire au lieu d'avoir que les nom dans la colonne 0 et que les codes dans la colonne 1, j'ai parfois des noms dans la colonne 1. Le soucie est que je ne sais pas ce qui ne vas pas dans mon code.

Si l'un de vous à déjà effectué ce genre de chose, un petit code exemple ne serait pas de refus,où alors des idées à propose de mon code ci-dessous je suis prenante !

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
 
 -*- coding: utf-8 -*-
 
import sys
from PyQt4 import QtCore
from PyQt4 import QtGui
from PyQt4.QtGui import QAbstractItemView
from PyQt4.QtCore import QObject, pyqtSignal
from PyQt4.QtCore import QEvent
 
import psycopg2
 
try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s
 
try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)
 
class Ui_Srid(QtGui.QDialog):
    signal_srid = pyqtSignal(str)
    def __init__(self, parent=None):
        super(Ui_Srid, self).__init__(parent)
        self.text = ''
 
        self.main = parent
        self.setObjectName(_fromUtf8("self"))
        self.setWindowModality(QtCore.Qt.WindowModal)
        self.resize(781,427)
 
        self.gridLayoutWidget = QtGui.QWidget(self)
        self.gridLayoutWidget.setGeometry(QtCore.QRect(10, 30, 761, 371))
        self.gridLayoutWidget.setObjectName(_fromUtf8("gridLayoutWidget"))
        self.gridLayout = QtGui.QGridLayout(self.gridLayoutWidget)
        self.gridLayout.setMargin(0)
        self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
 
        self.lineEdit = QtGui.QLineEdit(self.gridLayoutWidget)
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
        self.gridLayout.addWidget(self.lineEdit, 0, 1, 1, 1)
 
        self.tableWidget = QtGui.QTableWidget(self.gridLayoutWidget)
        self.tableWidget.setObjectName(_fromUtf8("tableWidget"))
        self.tableWidget.setColumnCount(0)
        self.tableWidget.setRowCount(0)
        self.gridLayout.addWidget(self.tableWidget, 1, 1, 1, 1)
        self.label = QtGui.QLabel(self.gridLayoutWidget)
        self.label.setObjectName(_fromUtf8("label"))
        self.gridLayout.addWidget(self.label, 0, 0, 1, 1)
 
        self.retranslateUi()     
        #Rempli la table
        self.sridData() 
        #Double cliaue : Selection de l'élement et fermeture de la fenêtre
        self.tableWidget.cellDoubleClicked.connect(self.returnSRID)
        QtCore.QObject.connect(self.tableWidget, QtCore.SIGNAL(_fromUtf8("doubleClicked(QModelIndex)")), self.close)
        QtCore.QMetaObject.connectSlotsByName(self)
        #Entré d'un texte dans la barre de recherche    
        self.lineEdit.textChanged.connect(self.on_qline_edit)
        self.lineEdit.editingFinished.connect(self.sridData)
        #Affiche le tout 
        self.show()
 
    def retranslateUi(self):
        self.setWindowTitle(_translate("Srid", "Srid", None))
 
    def sridData(self): ##REMPLISSAGE
        self.text = self.lineEdit.text()
        if  self.text=="":
            try:
                conn = psycopg2.connect("dbname='qgis_db' user='postgres' host='localhost' password='postgresql'")
            except:
                print "I am unable to connect to the database"
            cur = conn.cursor()        
            data= cur.execute("SELECT srid_label, srid_text FROM spatial_ref_sys;")
            data = cur.fetchall()          
            lignes = len(data)
            columns =  len(data[0])
            i = 0
            j = 0
            self.tableWidget.setRowCount(lignes)
            self.tableWidget.setColumnCount(columns)
            self.tableWidget.setHorizontalHeaderLabels(['Label sird', 'srid'])
            self.tableWidget.horizontalHeader().setResizeMode(0, QtGui.QHeaderView.Stretch)
 
            for i in range(lignes):
                for j in range(columns):
                    item = QtGui.QTableWidgetItem(data[i][j])
                    self.tableWidget.setItem(i, j, item)
        else :
            self.on_qline_edit(self.text)    
 
    def returnSRID(self, row, col): # Apellé seulemment lorsque l'on selection une ligne
        column = col or 1
        self.srid_selected = self.tableWidget.item(row, column).text()
        self.main.selected = self.srid_selected
 
    def on_qline_edit(self, text):
        if text :
            items = self.tableWidget.findItems(self.lineEdit.text(), QtCore.Qt.MatchContains) # Qt::MatchRegExp ou Qt::MatchWrap
            if items:
                #Récupère les élements de la recherche
                self.data_ligne=[]
                self.data_col=[]
                self.data_seach =[]
                for item in items :
                    row = item.row()+1
                    self.data_ligne.append(self.tableWidget.item(item.row(), item.column()).text())
                    self.data_col.append(self.tableWidget.item(item.row(), item.column()).text())
                #Elements de la recherche
                self.data_seach={'A':self.data_ligne, 'B':self.data_col}
                #Remplissage du tableau avec les résultats de la recherche rapide
                self.tableWidget.setRowCount(len(self.data_ligne))
                self.tableWidget.setColumnCount(len(self.data_seach))
                self.tableWidget.setHorizontalHeaderLabels(['Label sird', 'srid'])
                n=0
                for key in self.data_seach:  
                    m = 0
                    for item in self.data_seach[key]:
                        self.item = QtGui.QTableWidgetItem(item)
                        self.tableWidget.setItem(m, n, self.item)
                        m += 1
                    n += 1
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QDialog()
    ui = Ui_Srid()
    sys.exit(app.exec_())

Merci d'avance pour votre aide !

[aurelie.guegan.15]

Re-Bonjour,

Je continue à chercher une solution à mon problème dans mon QtableWidget. J'ai repris depuis zéro et trouvé une seconde manière de faire ce que je veut faire qui est plus ou moins plus "simple". Le principe est de récupérer la liste données initiales qui servent à remplir le tableau et de faire une recherche non plus directement dans le tableau mais dans la liste.

Voici comment j'ai procédé :

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
if text :
            self.lst_txt=[]
            self.lst_nom=[]
            self.lst_srid=[]
            for i in self.data:  #self.data liste des données de la base 
                fd = i[0].find(text)
                if not fd ==-1:
                    self.lst_txt.append(i)
            #Remplissage du tableau avec les résultats de la recherche rapide
            self.tableWidget.setRowCount(len(self.lst_txt))
            self.tableWidget.setColumnCount(len(self.lst_txt[0]))
            self.tableWidget.setHorizontalHeaderLabels(['Label sird', 'srid'])
            for i in range (len(self.lst_txt)):
                for j in range(len(self.lst_txt[0])) :
                    self.item = QtGui.QTableWidgetItem(self.lst_txt[i][j])
                    self.tableWidget.setItem(i, j, self.item)

Ce qui me dérange :
Mon unique problème avec cette solution est que je doit entrer des mots clés exacts. j'ai donc un soucie si je ne met pas de majuscule ou que je met un espace en trop etc etc...

Question :
Comment faire pour faire une recherche dans un string de manière plus "souple", sans prendre en comprend en compte les majuscules, les espaces ou encore l'ordre des mots ?

Merci d'avance pour vos conseils !

[tyrtamos]

Bonjour,

Avec un QTableWidget, la recherche semble limitée à .findItems, mais il existe pas mal d'options pour préciser ce qu'on veut:

Extrait de la doc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Qt::MatchExactly	0	Performs QVariant-based matching.
Qt::MatchFixedString	8	Performs string-based matching. String-based comparisons are case-insensitive unless the MatchCaseSensitive flag is also specified.
Qt::MatchContains	1	The search term is contained in the item.
Qt::MatchStartsWith	2	The search term matches the start of the item.
Qt::MatchEndsWith	3	The search term matches the end of the item.
Qt::MatchCaseSensitive	16	The search is case sensitive.
Qt::MatchRegExp	4	Performs string-based matching using a regular expression as the search term.
Qt::MatchWildcard	5	Performs string-based matching using a string with wildcards as the search term.
Qt::MatchWrap	32	Perform a search that wraps around, so that when the search reaches the last item in the model, it begins again at the first item and continues until all items have been examined.
Qt::MatchRecursive	64	Searches the entire hierarchy.

On peut aussi faire une recherche avec les méthodes Python: boucles sur les lignes et les colonnes => extraction du contenu des cases => on peut tout faire => comparer les données brutes ou converties en majuscule (.upper()), faire des tests regex et même rechercher de mots similaires avec ratio de similitude. Pour la nature des comparaisons que tu souhaites: précise ce que tu cherches.

Mais avec un QTableWidget, on n'obtient pas le résultat sous forme du même tableau qui présente les même données sous des formes différentes: ça, c'est plutôt du ressort d'un QTableView qui ne fait qu'afficher les données gérées par ailleurs (base de données, liste, ...). Avec un QTableView, on utiliserait un QSortFilterProxyModel pour ajouter des capacités de tri/filtrage.