Récupérer l'index du zone de texte

Version imprimable

Bonsoir,
Voici encore une question :
j'aurai besoin de connaitre l'index du QLinedit actif.
je vous mets un bout de code je cherche à afficher dans l'étiquette l'index de txt actif soit par un click de souris ou par l'activation via la touche Tab

Code:

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
import sys
from PySide import QtCore,QtGui
 
class Feuille(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)
        self.txt=[0]*8
        for i in range(8):
            self.txt[i]=QtGui.QLineEdit(str(i),self)
            self.txt[i].cursorPositionChanged.connect(self.affiche)
 
        self.label=QtGui.QLabel('Index',self,alignment=QtCore.Qt.AlignCenter)
 
        grid=QtGui.QGridLayout()
        grid.setSpacing (10)
        for i in range(8):
             grid.addWidget (self.txt[i],i,0)
        grid.addWidget (self.label,i+1,0)
        self.setLayout (grid)
 
    def affiche(self):
        self.label.setText(???)
 
 
 
if __name__ == '__main__':
    app = QtGui.QApplication (sys.argv)
    root = Feuille()
    root.show()
    sys.exit(app.exec_())

Merci de votre aide

Bonjour,

Voilà une solution possible.

J'ai utilisé pour chaque QLineEdit le signal editingFinished qui est émis en fin d'édition, y compris lors de la perte du focus.

J'en profite pour passer l'index du QLineEdit qui vient de perdre le focus grâce à partial, mais ce n'était pas demandé.

Dans le self.affiche, je cherche, grâce à une boucle, quel est le QLineEdit qui a le focus, et j'affiche l'ancien index => le nouvel index. Il y a peut-être mieux que de chercher avec une boucle, mais je n'ai pas trouvé.

J'ai fait ça sous PyQt4, mais ça doit marcher aussi sous PySide: il suffit de changer l'importation.

Code:

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# Python 2.7
 
import sys
from PyQt4 import QtCore, QtGui
from functools import partial
 
#############################################################################
class Feuille(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)
        self.txt=[0]*8
        for i in range(8):
            self.txt[i]=QtGui.QLineEdit(str(i),self)
            self.txt[i].editingFinished.connect(partial(self.affiche, i))
 
        self.label=QtGui.QLabel('0',self,alignment=QtCore.Qt.AlignCenter)
 
        grid=QtGui.QGridLayout()
        grid.setSpacing (10)
        for i in range(8):
             grid.addWidget (self.txt[i],i,0)
        grid.addWidget (self.label,i+1,0)
        self.setLayout (grid)
 
    def affiche(self, i):
 
        for k in range(0, 8):
            if self.txt[k].hasFocus():
                self.label.setText(u"%d => %d" % (i,k))                
                break
 
#############################################################################
if __name__ == '__main__':
    app = QtGui.QApplication (sys.argv)
    root = Feuille()
    root.show()
    sys.exit(app.exec_())

Autre possibilité: faire un QLineEdit personnalisé qui émet un nouveau signal d'entrée de focus récupérable. Si cette solution t'intéresse, dis-le.

[edit]: j'ai une solution simple, sans boucle!

Principe: Chaque QLineEdit a une méthode focusInEvent qui est lancée à chaque acquisition du focus. Alors, on détourne son adresse pour que cette méthode lance self.affiche. On utilise partial pour passer en même temps l'index du QLineEdit qui vient d'avoir le focus, ce qui permettra de l'afficher.

Voilà le nouveau code:

Code:

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# Python 2.7
 
import sys
from PyQt4 import QtCore, QtGui
from functools import partial
 
#############################################################################
class Feuille(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)
        self.txt=[0]*8
        for i in range(8):
            self.txt[i]=QtGui.QLineEdit(str(i),self)
            self.txt[i].focusInEvent = partial(self.affiche, i=i)
 
        self.label=QtGui.QLabel('Index',self,alignment=QtCore.Qt.AlignCenter)
 
        grid=QtGui.QGridLayout()
        grid.setSpacing (10)
        for i in range(8):
             grid.addWidget (self.txt[i],i,0)
        grid.addWidget (self.label,i+1,0)
        self.setLayout (grid)
 
    def affiche(self, event, i=0):
 
        self.label.setText(u"%d" % (i,))
 
#############################################################################
if __name__ == '__main__':
    app = QtGui.QApplication (sys.argv)
    root = Feuille()
    root.show()
    sys.exit(app.exec_())

merci Tyrtamos pour ta réactivité.
a première vue le premier code fait mon affaire, mais si j'ajoute un autre widget comme un QPushButton et qu'une fois qu'il perd le focus pour un QLineEdit il n'y a pas de mise à jour avec self.affiche pour cause le signal editingFinished ?
je remets le code avec le bouton :

Code:

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
import sys
from PyQt4 import QtCore, QtGui
from functools import partial
 
#############################################################################
class Feuille(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)
        self.txt=[0]*8
        for i in range(8):
            self.txt[i]=QtGui.QLineEdit()
            self.txt[i].editingFinished.connect(partial(self.affiche, i))
 
        self.label=QtGui.QLabel('0',self,alignment=QtCore.Qt.AlignCenter)
        self.bouton=QtGui.QPushButton('Fermer')
 
        grid=QtGui.QGridLayout()
        grid.setSpacing (10)
        for i in range(8):
             grid.addWidget (self.txt[i],i,0)
        grid.addWidget (self.label,i+1,0)
        grid.addWidget (self.bouton,i+2,0)
        self.setLayout (grid)
 
    def affiche(self, i):
 
        for k in range(0, 8):
            if self.txt[k].hasFocus():
                self.label.setText(u"%d => %d" % (i,k))              
                break
 
#############################################################################
if __name__ == '__main__':
    app = QtGui.QApplication (sys.argv)
    root = Feuille()
    root.show()
    sys.exit(app.exec_())

Le 2ème code est donc mieux adapté, mais la mise en évidence du QLineEdit n'est pas habituelle, le curseur n’apparaît pas ou il reste figer !

peu être que la possibilité d'un QLineEdit personnalisé est la solution, mais la j'ai peur de ne pas suivre, pour son utilisation.

je pense avoir résolu mon problème.
je mets mon code final au cas ou ?

Code:

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
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3.2
 
import sys
from PySide import QtCore, QtGui
 
#############################################################################
class Feuille(QtGui.QWidget):
    def __init__(self):
        QtGui.QWidget.__init__(self)
        self.txt=[0]*8
        for i in range(8):
            self.txt[i]=QtGui.QLineEdit()
            self.txt[i].installEventFilter(self)
        self.bouton=QtGui.QPushButton('imprimer')
        self.label=QtGui.QLabel(alignment=QtCore.Qt.AlignCenter)
 
        grid=QtGui.QGridLayout()
        grid.setSpacing (10)
        for i in range(8):
             grid.addWidget (self.txt[i],i,0)
        grid.addWidget (self.label,i+1,0)     
        grid.addWidget (self.bouton,i+2,0)
        self.setLayout (grid)
 
    def eventFilter(self, obj, event):
        if event.type() == QtCore.QEvent.FocusIn:
            if obj in self.txt:
                index = self.txt.index(obj)
                self.label.setText("index n° %d" % (index))     
        return False
 
#############################################################################
if __name__ == '__main__':
    app = QtGui.QApplication (sys.argv)
    root = Feuille()
    root.show()
    sys.exit(app.exec_())