Comment transférer une variable de fenêtre A vers fenêtre B ? [Résolu]

[Rapidego]

Bonjour,

Après avoir chercher en vain durant 8 jours dans différents forums je me permet de vous exposer mon problème.

Je suis un retraité qui s'intéresse à la programmation c++ en utilisant Qt.

J'ai déjà réussi pas mal de chose mais cette fois ci ça bloque!

Je veux transférer une somme qui est le résultat d'un calcul et se trouvant dans un Q Label dans ma fenêtre A.

Donc transférer cette somme via une variable dans une fenêtre B pour y effectuer un autre calcul.

Les fenêtres sont en places je peux les ouvrir et fermer effectuer des calculs mais hélas pas transférer ma variable dans la fenêtre B.

Merci pour une aide qui me sera précieuse.

[saad.hessane]

Bonjour,

Cela dépend de comment l'application est faite. Plus de détails sur comment sont créés les deux fenêtre seraient bienvenue.

Pour répondre de manière générale, Qt fournit un mécanisme de communication qui est les signaux/slot. Créez un signal personnalisé dans la classe de la fenêtre A (void calculeTermine(int valeur)), et un slot personnalisé dans la classe de la fenêtre B (void setValeur(int valeur)). Connectez les deux et le tour est joué.
Lorsque le signal est émit (emit calculeTermine(maVariable)), le slot de la fenêtre B est appelé.

Mais il y a tellement d'autres manières de faire que, comme je vous ai dit, cela dépend de votre application.

[koala01]

Salut,

En effet, cela dépend grandement de la manière dont les deux fenêtres sont créées.

Comme il y a trois situations possibles, commençons peut etre par le "kifékoi", pour être sur de parler de la même chose

Je vais donc partir du principe que la fenêtre A est la classe qui dispose de ton QLabel dans lequel se trouve le résultat du calcul et que la fenêtre B est la classe qui doit récupérer ce résultat.

La situation la plus simple est si la fenêtre B est ouverte uniquement au départ de la fenêtre A : il te "suffit" de fournir la valeur du résultat comme argument dans le constructeur de B, et, bien sur, d'enregistrer cette valeur dans un membre de la fenêtre B

La situation inverse (c'est la fenêtre B qui ouvre la fenêtre A) peut se résoudre de deux manières:

Si B est le parent de A, tu peux "tout simplement" placer une fonction "setResultat" dans B et l'appeler depuis A lorsque le résultat est disponible ou utiliser le principe indiqué par saad.

La troisième situation est celle ou A et B fonctionne de manière tout à fait autonome (créées par une troisième fenetre que nous nommerions C), et, dans ce cas, le système de signaux / slots indiqué par saad est la solution la plus adaptée

Note que le système de signaux / slots peut etre utilisé dans les trois situations, mais qu'il est parfois simplement inutile d'y recourir juste "pour se faire du mal"

[Rapidego]

Un grand bonjour à saad.hessane, et à koala01

Merci de m'avoir conseillé aussi rapidement.

J'ai essayé suivant vos différents conseils mais quelque part ça bloque .

Ci-joint en pièce jointe mon code. La fenêtre A (fenetre) ouvre bien la fenetre B (fenfrais).

Voici le résultat de la compilation :
erreur : 'fenfrais' was not declared in this scope

[saad.hessane]

Bonjour,

Le mieux est de fournir un code source. Le message d'erreur est un peu flou sans le code source qui l'a provoqué.

[Rapidego]

Bonjour et merci de répondre

mon code source

Mon fichier calculaddition.cpp

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
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
#include "calculaddition.h"
#include "ui_calculaddition.h"
#include <QInputDialog>
#include <QPrintDialog>
#include <QPrinter>
#include <QPainter>
#include <QRect>
#include <QPushButton>
#include <QFile>
#include <QTextStream>
#include <QFileDialog>
#include <QDataStream>
#include <QTextCodec>
 
 
CalculAddition::CalculAddition(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::CalculAddition)
{
    ui->setupUi(this);  //génère les fichier *.cpp et *.h
 
    //création d'un slot personalisé pour calculer la somme.
    connect(ui->calculer, SIGNAL(clicked()), this,
            SLOT(calculer()));
 
    //création d'un slot personalisé pour ouvrir la boite de dialogue input.
    connect(ui->Revenus, SIGNAL(clicked()), this,
            SLOT(entrerSomme()));
 
    //création d'un slot personalisé pour ouvrir la boite de dialogue imprimer.
    connect(ui->Imprimer, SIGNAL(clicked()), this,
            SLOT(Imprimer()));
 
    //création d'un slot personalisé pour enregistrer en fichier binaire.
    connect(ui->Sauvegarde, SIGNAL(clicked()), this,
            SLOT(Enregistrer()));
 
    //création d'un slot personalisé pour ouvrir un fichier binaire.
    connect(ui->Afficher, SIGNAL(clicked()), this,
            SLOT(OuvrirFichier()));
 
    //création d'un slot personalisé pourouvrir la feuille 2 des frais.
    connect(ui->OuvreFen2, SIGNAL(clicked()), this,
            SLOT(AfficheFenFrais()));
 
 
    connect(ui->OK, SIGNAL(clicked()), this, SLOT(envoi_infos()));
 
}
 
 
//**********Méthode en créant un Slot**********************************************
void CalculAddition::calculer()
{
    int somme = ui->Prix->value() * ui->Quantite->value();  //calculer multiplier avec 2 spinBoxs
    ui->Total->setNum(somme);  // affichache du total dans le QLabel
 
}
//********Fin de la méthode en créant un Slot***************************************
 
 
void CalculAddition::entrerSomme()
{
 
    int entier = QInputDialog::getInteger(this, "Nombre", "Entrez un nombre entier");
 
    ui->Prix->setValue(entier); // copie la variable entier dans spinBox Prix
 
}
 
//*****Création d'un slot imprimer**************************************************
void CalculAddition::Imprimer()
{
        QString data = ui->Total->text();   //récupère la valeur du QLabel Réponse
        int somme2 = ui->Prix->value(); //récupère la valeur du QSPinBox (Prix)
        int somme3 = ui->Quantite->value();  //récupère la valeur du QSPinBox (Quantite)
 
 
 
//********************
 
  QPrinter imprimante(QPrinter::HighResolution); //crée un objet imprimante en statique
  imprimante.setPageSize(QPrinter::A4); //format de la feuille
  QPrintDialog *dialog = new QPrintDialog(&imprimante);  //appel de la boite pour imprim
  if (dialog->exec() == QDialog::Accepted)
    {
      QPainter Painter; //crée en statique un objet pour dessiner
      Painter.begin(&imprimante);   //début du dessin
 
      QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));//ça marche pour imprimer les accents.
 
      Painter.setPen(Qt::black);
      Painter.setFont(QFont("Arial", 12));
 
      Painter.drawText(QPoint (300,4000), "éèàçààà");
 
      Painter.drawText(QPoint(300,1830), "3 - Salut essai d'impression!");  //imprime ce texte
 
      QString s2 = QString::number(somme2); //conversion de somme2 int en s2 QString
      QString s3 = QString::number(somme3); //conversion de somme3 int en s3 QString
 
      Painter.drawText(QPoint(300,2700), s2); //imprime la variable s2 isue de somme2(pour la SPinBox Prix)
      Painter.drawText(QPoint(300,3000), s3); //imprime la variable s3 isue de somme3 (pour la SPinBox Quantite)
      Painter.drawText(QPoint(300,3300), data); //imprime la variable (issue de QLabel réponse)
 
      QRect rectangle(QPoint(1410,3220), QSize(2880, 1960));  //crée objet rectangle coordonnées et dimensions
      Painter.setPen(QPen(Qt::blue, 12)) ;  //épaisseur de ligne ici 12, couleur bleu
      Painter.setBrush(QBrush(Qt::white)) ; //remplissage en blanc
 
      Painter.drawRect(rectangle);  //dessine le rectangle
 
  Painter.end();   // fin du dessin
    }
}
 
void CalculAddition::Enregistrer()  //Enregistrer dans un fichier binaire
{
    QString filtre;//filtre correspond au filtre selectionné (dans cet exemple
    //c'est "Fichier Binaire(*.bin *.* *)" vu qu'il n'y a qu'un seul filtre
 
    //***Ouvre la boite de dialogue Enregistrer avec le chemin et les options de fichier
        //avec ou sans extensions.***************************************************
    QString fichier = QFileDialog::getSaveFileName(this, "Enregistrer un fichier",
                                                   "/home/henninger/Essais", "Fichier Binaire (*.* *)", &filtre);
 
    //Initialisation de la QString somme qui sera enregistrée dans le fichier binaire
    QString somme = ui->Total->text();
 
    //Initialisation des 2 int: somme2 et somme3 (SPinBox) qui seront enregistrés dans le fichier binaire
    int somme2 = ui->Prix->value();
    int somme3 = ui->Quantite->value();
 
 
    QFile file(fichier);
    //Ouverture du fichier en lecture seul
    if (!file.open(QIODevice::WriteOnly))
    return ;
 
    //Création de notre QDataStream à partir de notre fichier précédemment ouvert
    QDataStream binStream(&file);
    //On spécifie la version de l'encodage qui va être utilisé par notre objet QDataStream
    binStream.setVersion(QDataStream::Qt_4_4);
    //On ecrit nos differents objet dans le fichier
    binStream << somme << somme2 << somme3;
    //On ferme le fichier
    file.close();
 
    return ;
}
 
 
void CalculAddition::OuvrirFichier()    //Ouverture d'un fichier binaire
{
    QString filtre; //filtre correspond au filtre selectionné (dans cet exemple
                    //c'est "Fichier Binaire(*.bin *.* *)" vu qu'il n'y a qu'un seul filtre
 
    //***Ouvre la boite de dialogue Ouvrir avec le chemin et les options de fichier
    //avec ou sans extensions.***************************************************
    QString fichier = QFileDialog::getOpenFileName(this, "Ouvrir un fichier",
                                                   "/home/henninger/Essais", "Fichier Binaire (*.* *)", &filtre);
 
    //Utilisation des mêmes types utilisés lors de l'ecriture
    QFile file(fichier);
    //Ouverture du fichier en lecture seul
    if (!file.open(QIODevice::ReadOnly))
    return ;
 
    //Création de notre QDataStream à partir de notre fichier précédemment ouvert
    QDataStream binStream(&file);
    /*On spécifie exactement le meme type d'encodage que celui utilisé lors de l'ecriture*/
    binStream.setVersion(QDataStream::Qt_4_4);
    //Lecture des differents objects contenus dans notre fichier binaire
 
    QString somme;   //déclaration variables
    int somme2, somme3; //déclaration variables
 
    //On ecrit nos differents objets dans le fichier
    binStream >> somme >> somme2 >> somme3;
 
    ui->Total->setText(somme);//affiche la somme dans Qlabel Total
    ui->Prix->setValue(somme2);//affiche la somme dans QSpinBox Prix
    ui->Quantite->setValue(somme3);//affiche la somme dans QSpinBox Quantite
 
    //Fermeture du fichier
    file.close();
 
    return ;
}
 
 
 
void CalculAddition::AfficheFenFrais()
{
 
 
    frais *fenfrais = new frais; //crée l'ojet fenetre pour les frais'
 
    fenfrais->show();       //affiche la fenêtre frais
 
}
 
void CalculAddition::envoi_infos()
{
    rep = ui->Total->text();    //récupère la somme du QLabel dans la variable rep
    emit recup_infos(rep);  //emission du signal
    //this->close();  //ferme la fenêtre
}
 
 
 
 
CalculAddition::~CalculAddition()   //destructeur
{
    delete ui;
}

*****************************************************************************
*****************************************************************************
Voici mon fichier calculaddition.h

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#ifndef CALCULADDITION_H
#define CALCULADDITION_H
#include <QWidget>
 
#include "frais.h"
 
namespace Ui
{
    class CalculAddition;
}
 
 
class CalculAddition : public QWidget
{
    Q_OBJECT
 
public:
    explicit CalculAddition(QWidget *parent = 0);
    ~CalculAddition();
 
//************************************************************************
    public slots :
        void calculer(); //la fonction calculer avec un Slot
 
        void entrerSomme(); //doit ouvrir une boite de dialogue
 
        void Imprimer();    //essai d'impression
 
        void Enregistrer(); //essai pour enregistrer en binaire
 
        void OuvrirFichier(); //essai pour ouvrir un fichier binaire
 
        void AfficheFenFrais();   //affiche la feuille 2 des frais
 
        void envoi_infos(); //récupère la variable à transmettre et émet le signal
 
//**********************************************************************************
signals :
        void recup_infos(QString);  //signal à émettre
 
public :
        CalculAddition(QString rep,QWidget *parent );
 
        QString rep;    //ma variable à transmettre
 
 
 
 
 
 
private:
    Ui::CalculAddition *ui;
};
 
#endif // CALCULADDITION_H

************************************************************************************
Voici mon fichier frais.cpp

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
#include <QApplication>
#include <QtGui>
#include "frais.h"
#include "ui_frais.h"
#include "calculaddition.h"
 
 
frais::frais(QWidget *parent) : QDialog(parent),
 
    ui(new Ui::frais)
{
    ui->setupUi(this);  //génère les fichier *.cpp et *.h
 
    connect(fenfrais , SIGNAL(recup_infos(QString)), this, SLOT(recevoirMontant(QString)));
}
 
void frais::recevoirMontant(QString rep)
{
   ui->recupVar->setText( rep);
 
}
 
 
frais::~frais()
{
    delete ui;
}

*******************************************************************************************

Voici mon fichier frais.h

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
#ifndef FRAIS_H
#define FRAIS_H
 
#include <QDialog>
#include "calculaddition.h"
 
namespace Ui
{
class frais;
}
 
class frais : public QDialog
{
    Q_OBJECT
 
public:
    explicit frais(QWidget *parent = 0);
    ~frais();
public :
public slots :
    void recevoirMontant(QString rep);
 
 
private:
    Ui::frais *ui;
};
 
#endif // FRAIS_H

************************************************************************************************

Voici mon fichier MainCalculAddition.cpp

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <QApplication>
#include <QtGui>
#include "calculaddition.h"
 
 
 
int main(int argc, char *argv[])
{
    QApplication app(argc,argv);
 
 
    CalculAddition fenetre;
    fenetre.show();
 
    return app.exec();
 
}

[saad.hessane]

Votre code possède certain problèmes :

• ligne 14, fichier frais.cpp : Vous connectez l'objet fenfrais à l'objet courant. fenfrais n'est pas déclaré comme étant membre de la classe "frais", d'où l'erreur en haut.
• De ce que j'apperçois à la ligne 196 du fichier calculaddition.cpp, vous souhaitez que fenfrais soit de type frais. Sauf qu'à la ligne 14 du fichier frais.cpp, vous declarez que l'objet fenfrais possède le signal recup_infos(QString). Ce qui est faux. La classe frais ne possède pas ce signal. C'est la classe CalculAddition qui le possède (calculaddition.h ligne 39).

[Rapidego]

Bonjour et merci de me répondre,

Décidément Qt et c++ c'est plus compliqué que JAVA car auparavant je programmais avec ce dernier le transfert était plus simple.
Je suis un jeune retraité de 72 ans! qui à du mal à suivre excusez moi.

Jusqu’à' à présent j'ai réussi avec ce petit programme: d'imprimer, de sauvegarder dans un fichier binaire, de faire de petits calculs de ré ouvrir mon fichier ainsi que de dessiner...

J'ai déjà écumé tous les forums sans trouver de réponses simples et compréhensible, je ne veux pas aller sur autre chose avant d'avoir compris ce transfert. Je n'ai jamais posté de l'aide sur un forum je me suis toujours débrouillé seul également en java.

Je n'arrive pas à comprendre connect avec un signal, comment arriver émettre de fenêtre en fenêtre?

Je vous remercie de bien vouloir me donner un exemple simple .

A plus et merci de me répondre.

[koala01]

En fait, il faut que la classe qui va essayer de connecter un signal à un slot ait connaissance aussi bien de l'objet qui dispose du signal que de l'objet qui dispose du slot...

A partir de là, il y a trois solutions :

L'objet qui émet le signal est carrément un membre de l'objet qui va devoir le traiter.

Ce cas est assez facile à gérer car c'est l'objet "parent" qui va s'occuper de la connexion.

Cela pourrait ressembler à quelque chose comme

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class MyDialog :public QDialog
{
    public;
        MyDialog( /* ... */);
    private slots:
        void 	myLineHasChanged( const QString & text )
    private:
        QLineEdit * myLine;
};
MyDialog::MyDialog(/* ... */)
{
    myLine = new QLineEdit(/*...*/);
    connect(myLine, SIGNAL(textEdited(const QString &) ) , this, SLOT(myLineHasChanged(const QString &) ) );
}

Dans le deuxième cas, il y a "quelque chose" qui connait l'objet qui va envoyer le signal ET celui qui va devoir le gérer, par exemple:

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
class DialogA : public QDialog
{
    /*... */
    signal :
        void myTextHasChanged(QString const &);
};
class DialogB : public QDialog
{
    public slots:
        void textAHasChanged(QString const &);
};
class AnotherDialog : public QDialog
{
    public:
        AnotherDialog (/* ... */ );
        /* ... */
}
 
AnotherDialog::AnotherDialog(/* ... */)
{
     DialogA * myA = new DialogA(/*... */);
     DialogB * myB = new DialogB(/* ... */);
     connect(myA, SIGNAL(myTextHasChanged(const QString &) ) , myB, SLOT(textAHasChanged(const QString &) ) );
}

Enfin, tu peux "simplement" t'arrange pour passer l'un des objets à l'autre pour qu'ils puissent s'y connecter:

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
class DialogA : public QDialog
{
    /*... */
    signal :
        void myTextHasChanged(QString const &);
    public slots :
        void somethingChangedInB();
};
 
class DialogB : public QDialog
{
    public:
        DialogB(DialogA *, /* ... */ );
    public slots:
        void textAHasChanged(QString const &);
    signals:
        void theBSignal();
};
class AnotherDialog : public QDialog
{
    public:
        AnotherDialog (/* ... */ );
        /* ... */
}
 
AnotherDialog::AnotherDialog(/* ... */)
{
     DialogA * myA = new DialogA(/*... */);
     DialogB * myB = new DialogB(myA, /* ... */);
}
DialogB::DialogB(DialogA * aDiag, /* ... */)
{
    connect(adiag, SIGNAL(myTextHasChanged(const QString &), this, SLOT(textAHasChanged(const QString &) ) );
    connect(this, SIGNAL(theBSignal()), aDiag, SLOT(somethingChangedInB() ) );
}

[Rapidego]

Bonjour koala01

Un grand merci pour ces longues explications.

J'ai tout imprimer et je vais de suite étudier et essayer, il faut bien que j'y arrive!!!

Je ne manquerai pas de te tenir au courant.

En attendant bonnes fêtes de fin d'année et encore merci pour tout.

[Rapidego]

Un grand bonjour à koala01 et à saad.hessane,

Après un long silence j'ai le plaisir de vous annoncer que j'ai réussi à transférer mes variables de la fenêtre A vers la fenêtre B.
Ceci n'a été possible que grâce à vos explications et conseils.
Je vous remercie pour votre aide.

Sincères salutations et encore merci.

rapidego

[Rapidego]

Bonjour

Au bout de 8 jours de recherche en vain sur tous les forums je me permet de vous demander de l'aide et merci par avance.

J'ai un nouveau problème avec Qt sans utiliser QTDesigner pour créer une application MDI.

J'ai créer une application MDI avec 3 fenêtres filles.

Ces fenêtres je veux qu'elles ne s'ouvrent qu'une seule fois en appuyant sur le menu fichier.

Or c'est le contraire qui se passe à chaque fois que je clique la même fenêtre fille s'ouvre à nouveau avec ma ligne de code Qt

Code :

feuille1->showMaximized;

Dans lattente d'une aide recevez mes sincères salutations rapidego

[Faridsarl]

Bonjour!! Suis un peu nouveau sur les fora mais je vais essayer de vous aider!
Est-ce-qu'à chaque fois qu'on clique sur le menu, vous appelez le slot(showMaximized) ou vous appelez un slot que vous avez vous même crée?

[Rapidego]

Lors de l'installation de Qt 5.0.1 il était impossible d'installer QtCreator.

Apparemment il n'est pas contenu dans Qt 5.0.1.

Dans les options d'installation de composants il est écrit en filigrane impossible de le sélectionner pour installation.

Que faut-il faire ... comment installer QtCreator avec Qt 5.01?
******************************************************************

Voila j'ai installé Qt5.01 et puis QtCreator 2.6.2 par après.

J'ai tout configuré dans QtCreator.

Quand je compile voila le résultat affiché: Le processus "mingw32-make.exe" a crashé.

Pourtant qmake fonctionne big_smile:\Qt\Qt5.0.1\5.0.1\mingw47_32\bin\qmake.exe" s'est terminé normalement.

Quoi faire pour arriver à compiler?

Merci pour toute aide

[Faridsarl]

Pour le Qt Creator 2.6.2, il faut que tu utilise mingw32 version 4.4.0 sinon avec les dernières versions du mingw32, ça ne marche!! Pour faire facile, si tu n'as pas encore désinstallé l'ancien Qt Creator, tu peux copier le dossier du mingw32 d'ancien Qt Creator à un emplacement différent de celui de l'ancien Qt Creator (tu peux par exemple mettre ça dans C:\Qt\). ensuite tu indiques au Qt Creator 2.6.2 le nouveau chemin du mingw32-4.4.0.

[Rapidego]

Bonjour

Merci a faridsarl.

J'avais déjà tout désinstallé

Maintenant j'ai installé QtCreator 4.6.2 avec la librairie Qt 4.8.4 et tout
fonctionne implacablement!

Salut et à +++