x object has no attribute y (PyQ4t et QLineEdit)

**EricStib** · 18/10/2008, 13h47

Bonjour à tous,

Pourriez-vous m'aider car, là je bloque sérieusement

Merçi d'avance,

Message d'erreur:

AttributeError: 'Ui_FenPrincipale' object has no attribute 'm_call_input'

J'ai une classe

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
def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        # BUG BUG BUG
        # je voudrais récupérer le contenu du QLineEdit (qui se nomme bien
        # m_call_input ) qui se trouve dans le fichier Fenetre.py et qui 
        # se trouve dans la classe Ui_FenPrincipale()
        obj_fen = Fenetre.Ui_FenPrincipale() 
        indicatif = obj_fen.m_call_input.text()
 
        # le code ci-dessous doit être faux aussi mais l'erreur ci-dessus 
        # m'empêche de continuer
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ")

Cette méthode fait appel à un (attribut) QLineEdit nommé m_call_input qui appartient à une autre classe

Code :

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

class Ui_FenPrincipale(object):

voici la déclaration de cet attribut:

Code :

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

1
2
3
4
5
6
7
8
self.m_call_input = QtGui.QLineEdit(self.centralwidget)
 
        font = QtGui.QFont()
        font.setPointSize(12)
        self.m_call_input.setFont(font)
        self.m_call_input.setObjectName("m_call_input")
        self.hboxlayout.addWidget(self.m_call_input)
        self.vboxlayout.addLayout(self.hboxlayout)

Je ne comprend pas comment il faut que j'appelle cet attribut (en fait, je crois que j'ai tout essayé

)

Voici le code complet:

Qt_Dupe_Call.py

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
# !/usr/bin/python
# -*-coding: utf-8-*-
from Fenetre import *
from PyQt4.QtGui import *
from PyQt4.QtCore import *
 
import sys
import os
 
 
class app(object):
    """Affiche la fenêtre et crée les slots"""
 
    def __init__(self,args):
        self.qtapp = QtGui.QApplication(sys.argv)
 
        # pour que le contenu des boites de dialogues par défaut
        # soient dans la langue de l'OS */
        locale = QtCore.QLocale.system().name()
        qtTranslator = QtCore.QTranslator()
        qtTranslator.load("qt_" + locale),
        QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        self.qtapp.installTranslator(qtTranslator)
 
        self.FenPrincipale = QtGui.QMainWindow()
        self.ui = Ui_FenPrincipale()
        self.ui.setupUi(self.FenPrincipale)
        self.FenPrincipale.show()
        # lecture du fichier au lancement du prg
        self.dc=dupe_call()
        self.dc.lecture_Call()
        # les slots
        # boutons
        self.qtapp.connect(self.ui.btn_quitter, QtCore.SIGNAL('clicked()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        # menus
        self.qtapp.connect(self.ui.action_Quitter_2, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        self.qtapp.connect(self.ui.actionA_Propos, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('aboutQt()'))
        #
        #autres
        self.qtapp.connect(self.ui.m_call_input, QtCore.SIGNAL('editingFinished()'), 
        self.ui.textEdit, dupe_call().existCall() )
 
 
        sys.exit(self.qtapp.exec_())
        self.dc.ecriture_Call()
 
class dupe_call(object):
    "vérifie si l'indicatif est déjà contacté (donc repris dans lae)" 
    def __init__(self):
        #self.ftexte = "call.txt"     # fichier contenant les indicatifs
        self.ftexte = "test.txt"      # fichier test pour les essais
        self.list_call = []  # creation d'une liste vide
 
    def lecture_Call(self):
        """ au lancement du programme, le fichier call.txt est lu et
        les indicatifs sont ajoutés à la liste """
 
        rep = os.getcwd() #renvoie le nom du répertoire courant
 
        #ouverture du fichier
        try:
            objFichier = open(rep+'/' + self.ftexte)
        except:
            # si le fichier n'existe pas encore il faut le créer
            # et l'ouvrir !!
 
            if QMessageBox.critical(None, "Fichier inexistant",(u"Le fichier "+ self.ftexte +u" est créé pour la première fois")):
                objFichier = open(self.ftexte, 'w') # si call.txt n'existe pas encore on le crée
                objFichier = open(rep+'/'+ self.ftexte) # on n'oublie pas d'ouvrir le fichier nouvellement créer
 
        # il faut lire le fichier call.txt et envoyer les indicatifs
        # vers la liste list_call
        try:
            for ligne in open(rep+'/'+ self.ftexte):
                for mot in ligne.split():
                    self.list_call.append(mot)
        except:
            QMessageBox.critical(None, u"Erreur de lecture",u"Il y a un problème de lecture du fichier "+ self.ftexte)
        finally:
            objFichier.close()
 
    def ecriture_Call(self):
        """
        sauvegarde dans un fichier des indicatifs contenu dans la liste
        pour une remise à jour de la dite liste au 
        prochain lancement du programme        
        """
 
        #ouverture du fichier
        objFichier = open(self.ftexte, 'w')
        try:
            x = 0
            while x < len(self.list_call):
                objFichier.write(upper(self.list_call[x]+' ') )
                x += 1
        except:
            QMessageBox.critical(None, "Erreur d'écriture","Il y a un problème d'écriture du fichier "+ self.ftexte)
        finally:
            objFichier.close()        
 
    def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        obj_fen = Ui_FenPrincipale() 
        indicatif = Ui_FenPrincipale().m_call_input.text()
 
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ") 
 
def main(args):
    mapp = app(args)
 
 
if __name__=="__main__":
        main(sys.argv)

et la fenetre, Fenetre.py

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
# -*- coding: utf-8 -*-
 
# Form implementation generated from reading ui file 'Qt_dupe_call.ui'
#
# Created: Wed Oct 15 19:55:17 2008
#      by: PyQt4 UI code generator 4.3.3
#
# WARNING! All changes made in this file will be lost!
 
from PyQt4 import QtCore, QtGui
 
class Ui_FenPrincipale(object):
    def setupUi(self, FenPrincipale):
        FenPrincipale.setObjectName("FenPrincipale")
        FenPrincipale.resize(QtCore.QSize(QtCore.QRect(0,0,414,314).size()).expandedTo(FenPrincipale.minimumSizeHint()))
 
        self.centralwidget = QtGui.QWidget(FenPrincipale)
        self.centralwidget.setGeometry(QtCore.QRect(0,24,414,266))
        self.centralwidget.setObjectName("centralwidget")
 
        self.vboxlayout = QtGui.QVBoxLayout(self.centralwidget)
        self.vboxlayout.setObjectName("vboxlayout")
 
        self.hboxlayout = QtGui.QHBoxLayout()
        self.hboxlayout.setObjectName("hboxlayout")
 
        self.label = QtGui.QLabel(self.centralwidget)
 
        font = QtGui.QFont()
        font.setFamily("Arial Black")
        font.setPointSize(12)
        self.label.setFont(font)
        self.label.setObjectName("label")
        self.hboxlayout.addWidget(self.label)
 
        self.m_call_input = QtGui.QLineEdit(self.centralwidget)
 
        font = QtGui.QFont()
        font.setPointSize(12)
        self.m_call_input.setFont(font)
        self.m_call_input.setObjectName("m_call_input")
        self.hboxlayout.addWidget(self.m_call_input)
        self.vboxlayout.addLayout(self.hboxlayout)
 
        self.vboxlayout1 = QtGui.QVBoxLayout()
        self.vboxlayout1.setObjectName("vboxlayout1")
 
        self.textEdit = QtGui.QTextEdit(self.centralwidget)
        self.textEdit.setObjectName("textEdit")
        self.vboxlayout1.addWidget(self.textEdit)
        self.vboxlayout.addLayout(self.vboxlayout1)
 
        self.hboxlayout1 = QtGui.QHBoxLayout()
        self.hboxlayout1.setObjectName("hboxlayout1")
 
        self.label_2 = QtGui.QLabel(self.centralwidget)
 
        font = QtGui.QFont()
        font.setFamily("Arial Black")
        font.setPointSize(12)
        self.label_2.setFont(font)
        self.label_2.setObjectName("label_2")
        self.hboxlayout1.addWidget(self.label_2)
 
        self.m_nbre_indicatifs = QtGui.QLabel(self.centralwidget)
 
        font = QtGui.QFont()
        font.setFamily("Arial Black")
        font.setPointSize(12)
        self.m_nbre_indicatifs.setFont(font)
        self.m_nbre_indicatifs.setAlignment(QtCore.Qt.AlignCenter)
        self.m_nbre_indicatifs.setObjectName("m_nbre_indicatifs")
        self.hboxlayout1.addWidget(self.m_nbre_indicatifs)
        self.vboxlayout.addLayout(self.hboxlayout1)
 
        self.hboxlayout2 = QtGui.QHBoxLayout()
        self.hboxlayout2.setObjectName("hboxlayout2")
 
        self.btn_ajouter = QtGui.QPushButton(self.centralwidget)
        self.btn_ajouter.setObjectName("btn_ajouter")
        self.hboxlayout2.addWidget(self.btn_ajouter)
 
        spacerItem = QtGui.QSpacerItem(40,20,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Minimum)
        self.hboxlayout2.addItem(spacerItem)
 
        self.btn_supprimer = QtGui.QPushButton(self.centralwidget)
        self.btn_supprimer.setObjectName("btn_supprimer")
        self.hboxlayout2.addWidget(self.btn_supprimer)
 
        spacerItem1 = QtGui.QSpacerItem(40,20,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Minimum)
        self.hboxlayout2.addItem(spacerItem1)
 
        self.btn_quitter = QtGui.QPushButton(self.centralwidget)
        self.btn_quitter.setObjectName("btn_quitter")
        self.hboxlayout2.addWidget(self.btn_quitter)
        self.vboxlayout.addLayout(self.hboxlayout2)
        FenPrincipale.setCentralWidget(self.centralwidget)
 
        self.menubar = QtGui.QMenuBar(FenPrincipale)
        self.menubar.setGeometry(QtCore.QRect(0,0,414,24))
        self.menubar.setObjectName("menubar")
 
        self.menu_Fichier = QtGui.QMenu(self.menubar)
        self.menu_Fichier.setObjectName("menu_Fichier")
 
        self.menu_Aide = QtGui.QMenu(self.menubar)
        self.menu_Aide.setObjectName("menu_Aide")
        FenPrincipale.setMenuBar(self.menubar)
 
        self.statusbar = QtGui.QStatusBar(FenPrincipale)
        self.statusbar.setGeometry(QtCore.QRect(0,290,414,24))
        self.statusbar.setObjectName("statusbar")
        FenPrincipale.setStatusBar(self.statusbar)
 
        self.actionAide = QtGui.QAction(FenPrincipale)
        self.actionAide.setObjectName("actionAide")
 
        self.actionA_Propos = QtGui.QAction(FenPrincipale)
        self.actionA_Propos.setObjectName("actionA_Propos")
 
        self.actionSupprimer_dernier = QtGui.QAction(FenPrincipale)
        self.actionSupprimer_dernier.setObjectName("actionSupprimer_dernier")
 
        self.action_Quitter = QtGui.QAction(FenPrincipale)
        self.action_Quitter.setObjectName("action_Quitter")
 
        self.actionSupprimer_indicatif = QtGui.QAction(FenPrincipale)
        self.actionSupprimer_indicatif.setObjectName("actionSupprimer_indicatif")
 
        self.action_Quitter_2 = QtGui.QAction(FenPrincipale)
        self.action_Quitter_2.setObjectName("action_Quitter_2")
        self.menu_Fichier.addAction(self.actionSupprimer_dernier)
        self.menu_Fichier.addAction(self.actionSupprimer_indicatif)
        self.menu_Fichier.addSeparator()
        self.menu_Fichier.addAction(self.action_Quitter_2)
        self.menu_Aide.addAction(self.actionAide)
        self.menu_Aide.addSeparator()
        self.menu_Aide.addAction(self.actionA_Propos)
        self.menubar.addAction(self.menu_Fichier.menuAction())
        self.menubar.addAction(self.menu_Aide.menuAction())
 
        self.retranslateUi(FenPrincipale)
        QtCore.QMetaObject.connectSlotsByName(FenPrincipale)
 
    def retranslateUi(self, FenPrincipale):
        FenPrincipale.setWindowTitle(QtGui.QApplication.translate("FenPrincipale", "PyQt Dupe call by ON4MIC", None, QtGui.QApplication.UnicodeUTF8))
        self.label.setText(QtGui.QApplication.translate("FenPrincipale", "Indicatif à vérifier", None, QtGui.QApplication.UnicodeUTF8))
        self.label_2.setText(QtGui.QApplication.translate("FenPrincipale", "Nombre d\'indicatifs", None, QtGui.QApplication.UnicodeUTF8))
        self.m_nbre_indicatifs.setText(QtGui.QApplication.translate("FenPrincipale", "0", None, QtGui.QApplication.UnicodeUTF8))
        self.btn_ajouter.setText(QtGui.QApplication.translate("FenPrincipale", "&Ajouter", None, QtGui.QApplication.UnicodeUTF8))
        self.btn_supprimer.setText(QtGui.QApplication.translate("FenPrincipale", "&Supprimer dernier", None, QtGui.QApplication.UnicodeUTF8))
        self.btn_quitter.setText(QtGui.QApplication.translate("FenPrincipale", "&Quitter", None, QtGui.QApplication.UnicodeUTF8))
        self.menu_Fichier.setTitle(QtGui.QApplication.translate("FenPrincipale", "&Fichier", None, QtGui.QApplication.UnicodeUTF8))
        self.menu_Aide.setTitle(QtGui.QApplication.translate("FenPrincipale", "&Aide", None, QtGui.QApplication.UnicodeUTF8))
        self.actionAide.setText(QtGui.QApplication.translate("FenPrincipale", "Aide", None, QtGui.QApplication.UnicodeUTF8))
        self.actionA_Propos.setText(QtGui.QApplication.translate("FenPrincipale", "A Propos", None, QtGui.QApplication.UnicodeUTF8))
        self.actionSupprimer_dernier.setText(QtGui.QApplication.translate("FenPrincipale", "Ajouter indicatif", None, QtGui.QApplication.UnicodeUTF8))
        self.action_Quitter.setText(QtGui.QApplication.translate("FenPrincipale", "&Quitter", None, QtGui.QApplication.UnicodeUTF8))
        self.actionSupprimer_indicatif.setText(QtGui.QApplication.translate("FenPrincipale", "Supprimer indicatif", None, QtGui.QApplication.UnicodeUTF8))
        self.action_Quitter_2.setText(QtGui.QApplication.translate("FenPrincipale", "&Quitter", None, QtGui.QApplication.UnicodeUTF8))
 
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    FenPrincipale = QtGui.QMainWindow()
    ui = Ui_FenPrincipale()
    ui.setupUi(FenPrincipale)
    FenPrincipale.show()
    sys.exit(app.exec_())

a+
EricStib

**nyko77** · 19/10/2008, 13h11

ça ne viendrai pas du fait que ta classe Ui_FenPrincipale ne contient de méthode __init__?
Je ne connais pas QT mais Je vois que ta classe hérite de la classe objet, et je pense qu'il faut appeler la méthode __init__ de la classe objet.

Code :

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

1
2
3
4
 
class Ui_FenPrincipale(object):
    def _init__(self):
        objet.__init__(self)

**EricStib** · 19/10/2008, 16h21

Bonjour et merçi,

Malheureusement, cela n'arrange rien à mon problème.

Mais je ne sais vraiment pas comment arranger cela.

Je pourrais remettre tout dans la classe App mais cela ne répondrait pas à la question : Qu'est-ce qui se passe dans ce foutu code

En tout cas, un grand merçi d'y avoir jeté un coup d'oeil.
Au plaisir,
EricStib

**nyko77** · 19/10/2008, 17h02

Tu as bien mis le

Code :

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

1
2
 
self.m_call_input = QtGui.QLineEdit(self.centralwidget)

dans le __init__.

Dans le code que tu donnes self.m_call_input est initialisé seulement quand tu appels setupUi.
ça expliquerai le AttributeError: 'Ui_FenPrincipale' object has no attribute 'm_call_input'

**EricStib** · 19/10/2008, 18h45

Re-bonjour,

J'appelle

Code :

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

self.ui.setupUi(self.FenPrincipale)

dans l'init de la classe App

Code :

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

1
2
3
4
class App(object):
    """Affiche la fenêtre et crée les slots"""
    def __init__(self,args):
        object.__init__(self)

Donc l'initialisation de

Code :

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

self.m_call_input = QtGui.QLineEdit(self.centralwidget)

devrait bien se faire dès que j'appelle

Code :

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

1
2
3
4
5
6
def main(args):
    mapp = App(args)
 
 
if __name__=="__main__":
    main(sys.argv)

Car j'appelle la Fenetre.py par l'intermédiaire de Qt_Dupe_Call.py

En fait, je ne suis plus sûr de rien, je viens de passer tout le we à essayer de trouver... c'est sûrement une erreur de débutant (que je suis !) mais je n'arrive pas à mettre le doigt dessus.

Je crois que je vais revoir mes bases

Encore merci pour ton aide,
Amicalement,
EricStib

**nyko77** · 19/10/2008, 19h21

Je pense que la notion d'objet n'est pas encore très clair pour toi.
Tu as 2 instance différente de Ui_FenPrincipale. La 1ere dans la classe app (self.ui) et la 2de dans la classe dupe_call (self.obj_fen).
Les instances fonctionnent séparément. Tu appels bien self.ui.setupUi dans la classe app, mais pas dans la classe dupe_call.
Je pense que ton erreur se trouve ici:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        #ici tu créés une nouvelle instance de Ui_FenPrincipale
        obj_fen = Ui_FenPrincipale() 
       #ici  m_call_input n'existe pas car tu n'as pas encore appelé setupUi
       #d'où le message d'erreur qui t'indique que m_call_input n'existe pas
       indicatif = Ui_FenPrincipale().m_call_input.text()
 
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ")

Je pas vraiment regardé à quoi ton code sert, mais si tu veux utilisé l'instance qui se trouve dans la classe app, dans la classe dupe_call, il faut la passer en argument.

**EricStib** · 19/10/2008, 20h15

Je pense que la notion d'objet n'est pas encore très clair pour toi.

C'est un euphémisme

Je vais revoir toutes mes bases car j'oublie trop de choses

Merçi pour tes explications qui m'ont ouvert les yeux !!

MAIS, je n'ai pas encore compris comment allez rechercher l'info de mon edit pour la passer en paramètre à ma fonction...

En tout cas, un grand merci, car maintenant je sais au moins où chercher.
a+
EricStib

**EricStib** · 21/10/2008, 21h51

Bonjour à tous,

Suite aux remarques de

nyko77

... et l'achat du livre sur Qt4 mais pour C++

je crois avoir trouvé comment résoudre mon problème mais je suis confronté à un "simple" problème de POO maintenant

En fait, je devrais faire "hériter" ma classe

Code :

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

def existCall(self):

de la classe

Code :

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

class App(object):

puisque, dans celle-çi se trouve

Code :

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

self.ui = Fenetre.Ui_FenPrincipale()

MAIS maintenant, j'ai ce message d'erreur suivant:

File "/home/eric/Py_sources2/Qt_Dupe_Call/Qt_Dupe_Call.py", line 53, in __init__
App.__init__(self)
TypeError: __init__() takes exactly 2 arguments (1 given)

... et je ne sais pas quoi ajouter à part self...

Ici, c'est vraiment un petit problème de POO .. mais je suis vraiment trop débutant

Si vous pouviez jeter un coup d'oeil à la classe

Code :

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

1
2
3
4
5
6
7
class Dupe_call(App):
    "vérifie si l'indicatif est déjà contacté (donc repris dans lae)" 
    def __init__(self):
        App.__init__(self)
        #self.ftexte = "call.txt"     # fichier contenant les indicatifs
        self.ftexte = "test.txt"      # fichier test pour les essais
        self.list_call = []  # creation d'une liste vide

J'ai mis le code complet ici (sans le fenetre qui est déjà plus haut dans ce message.

Un grand merci pour votre attention et pour votre aide !!!

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
# !/usr/bin/python
# -*-coding: utf-8-*-
#from Fenetre import *
#from PyQt4.QtGui import *
#from PyQt4.QtCore import *
from PyQt4 import QtCore, QtGui
 
import Fenetre
import sys
import os
 
 
class App(object):
    """Affiche la fenêtre et crée les slots"""
    def __init__(self,args):
        self.qtapp = QtGui.QApplication(sys.argv)
 
        # pour que le contenu des boites de dialogues par défaut
        # soient dans la langue de l'OS */
        locale = QtCore.QLocale.system().name()
        qtTranslator = QtCore.QTranslator()
        qtTranslator.load("qt_" + locale),
        QtCore.QLibraryInfo.location(QtCore.QLibraryInfo.TranslationsPath)
        self.qtapp.installTranslator(qtTranslator)
 
        self.FenPrincipale = QtGui.QMainWindow()
        self.ui = Fenetre.Ui_FenPrincipale()
        self.ui.setupUi(self.FenPrincipale)
        self.FenPrincipale.show()
        # lecture du fichier au lancement du prg
        self.dc=Dupe_call()
        self.dc.lecture_Call()
        # les slots
        # boutons
        self.qtapp.connect(self.ui.btn_quitter, QtCore.SIGNAL('clicked()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        # menus
        self.qtapp.connect(self.ui.action_Quitter_2, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('quit()'))
        self.qtapp.connect(self.ui.actionA_Propos, QtCore.SIGNAL('triggered()'), 
        self.qtapp, QtCore.SLOT('aboutQt()'))
        #
        #autres
        self.qtapp.connect(self.ui.m_call_input, QtCore.SIGNAL('editingFinished()'), 
        self.ui.textEdit, Dupe_call().existCall() )
 
        sys.exit(self.qtapp.exec_())
        self.dc.ecriture_Call()
 
class Dupe_call(App):
    "vérifie si l'indicatif est déjà contacté (donc repris dans lae)" 
    def __init__(self):
        App.__init__(self)
        #self.ftexte = "call.txt"     # fichier contenant les indicatifs
        self.ftexte = "test.txt"      # fichier test pour les essais
        self.list_call = []  # creation d'une liste vide
 
    def lecture_Call(self):
        """ au lancement du programme, le fichier call.txt est lu et
        les indicatifs sont ajoutés à la liste """
        rep = os.getcwd() #renvoie le nom du répertoire courant
        #ouverture du fichier
        try:
            objFichier = open(rep+'/' + self.ftexte)
        except:
            # si le fichier n'existe pas encore il faut le créer
            # et l'ouvrir !!
            if QtCore.QMessageBox.critical(None, "Fichier inexistant",(u"Le fichier "+ self.ftexte +u" est créé pour la première fois")):
                objFichier = open(self.ftexte, 'w') # si call.txt n'existe pas encore on le crée
                objFichier = open(rep+'/'+ self.ftexte) # on n'oublie pas d'ouvrir le fichier nouvellement créer
        # il faut lire le fichier call.txt et envoyer les indicatifs
        # vers la liste list_call
        try:
            for ligne in open(rep+'/'+ self.ftexte):
                for mot in ligne.split():
                    self.list_call.append(mot)
        except:
            QtCore.QMessageBox.critical(None, u"Erreur de lecture",u"Il y a un problème de lecture du fichier "+ self.ftexte)
        finally:
            objFichier.close()
 
    def ecriture_Call(self):
        """
        sauvegarde dans un fichier des indicatifs contenu dans la liste
        pour une remise à jour de la dite liste au 
        prochain lancement du programme        
        """
        #ouverture du fichier
        objFichier = open(self.ftexte, 'w')
        try:
            x = 0
            while x < len(self.list_call):
                objFichier.write(self.list_call[x]+' ').upper()
                x += 1
        except:
            QtCore.QMessageBox.critical(None, "Erreur d'écriture","Il y a un problème d'écriture du fichier "+ self.ftexte)
        finally:
            objFichier.close()        
 
    def existCall(self):
        """ vérifie dans la liste si l'indicatif a déjà été contacté"""
        indicatif = self.ui.m_call_input.text()
 
        # le code ci-dessous doit être faux aussi mais l'erreur ci-dessus 
        # m'empêche de continuer
        if indicatif in self.list_call:
            # il est déjà contacté        
            self.textEdit.setText("DUPE - DUPE - DUPE")
        else:
            self.textEdit.setText("NEW ONE - NEW ONE - NEW ONE ") 
 
def main(args):
    mapp = App(args)
 
 
if __name__=="__main__":
    main(sys.argv)

**nyko77** · 21/10/2008, 23h29

Ta classe App attent un argument args.

Code :

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

1
2
3
4
 
class App(object):
    """Affiche la fenêtre et crée les slots"""
    def __init__(self,args):

Donc pour créer une instance de App il faut faire:

Code :

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

1
2
 
monApp = App(monArgument)

Si tu n'as besoin de args tu peux tout simplement l'enlever, et ça supprimera ton message d'erreur. Mais un nouveau va certainement apparaître.

Tes réflèxions ci-dessus n'ont aucun sens, tu n'as pas bien compris ce qu'était l'héritage. Je te conseil de lire (et comprendre) ça:
http://python.developpez.com/cours/TutoSwinnen/.
Il aborde la bibliothèque graphique Tkinter, ça me semble plus judicieux de commencer par là.

Je ne suis pas sur d'avoir compris ce que tu voulais faire mais si tu veux manipuler une fenêtre à partir de 2 classe il faut la passer en argument.

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
 
Class Fenetre:
    def __init__(self):
        #création de la fenêtre
 
Class A:
    def __init__(self):
        #on créé l'objet fenêtre
        self.objetFenetre = Fenetre()
        #on passe en argument l'instance de la fenêtre.
        objetB = B(self.objetFenetre)
 
Class B:
    def __init__(self, objetFenetre):
        #on récupère l'instance de la fenêtre
        self.objetFenetre = objetFenetre
 
monA = A()

**EricStib** · 23/10/2008, 23h00

oui, bon, j'ai compris, je reprend mon étude de Python et je reviendrai dans quelques mois

x object has no attribute y (PyQ4t et QLineEdit)

PyQt Python

Discussions similaires

Partager

Partager