Gestion d'une QList de QLabel

Bonjour,

Alors voila, je souhaite réaliser un chat ou les personnes connectées puissent se déplacer sur une map en dessous du chat.

Pour cela je procède de la façon suivante :
Chaque client possède ces coordonnés en x et en y.
Il possède aussi une QList de QString avec tout les pseudo des connectés. Et une QList de Qlabel avec un Qlabel par personne.

A chaque fois qu'un client fait un mouvement, il modifie ces coordonné et envoi un QString à tout les client avec son pseudo , son x et son y par le serveur.

Quand un client reçoit un mouvement d'un client, il modifie son Qlabel.

Tout marche, les clients se connecte, ils s'envoient les QString mais je n'arrive pas à afficher l'image. Je dois mal gérer ma QList de Qlabel.

Voici le code :

Code:

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

FenClient.cpp la ou il y a un soucis c'est dans void FenClient::donneesRecues()

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
 * *
 #include "FenClient.h"
 
 FenClient::FenClient()
 {
 ** *setupUi(this);
 
 ** *socket = new QTcpSocket(this);
 ** *connect(socket, SIGNAL(readyRead()), this, SLOT(donneesRecues()));
 ** *connect(socket, SIGNAL(connected()), this, SLOT(connecte()));
 ** *connect(socket, SIGNAL(disconnected()), this, SLOT(deconnecte()));
 ** *connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(erreurSocket(QAbstractSocket::SocketError)));
 
 ** *tailleMessage = 0;
 }
 
 void FenClient::on_connexion_clicked()
 {
 ** *listeMessages->append(tr("<em>Tentative de connexion en cours...</em>"));
 ** *connexion->setEnabled(false);
 
 ** *socket->abort(); // On désactive les connexions précédentes s'il y en a
 ** *socket->connectToHost("127.0.0.1", 50885); // On se connecte au serveur demandé
 }
 
 void FenClient::on_gauche_clicked()
 {
 ** *QByteArray paquet;
 ** *QDataStream out(&paquet, QIODevice::WriteOnly);
 
 ** *// On prépare le paquet à envoyer
 ** *for (int i = 0; i < player.size(); i++)
 ** *{
 ** * * * *listeMessages->append(player[i]);
 ** * * *//player[i]->write(paquet);
 ** *}
 ** *//QString messageAEnvoyer = "cord+" + pseudo->text() + "+" + QString::number(x(0, 1)) + QString::number(y(0, 0));
 
 ** *//out << (quint16) 0;
 ** *//out << messageAEnvoyer;
 ** *//out.device()->seek(0);
 ** *//out << (quint16) (paquet.size() - sizeof(quint16));
 ** *//socket->write(paquet); // On envoie le paquet
 }
 
 void FenClient::on_droite_clicked()
 {
 ** *QByteArray paquet;
 ** *QDataStream out(&paquet, QIODevice::WriteOnly);
 
 ** *// On prépare le paquet à envoyer
 ** *QString messageAEnvoyer = "cord+" + pseudo->text() + "+" + QString::number(x(1, 0)) + "+" + QString::number(y(0, 0));
 
 ** *out << (quint16) 0;
 ** *out << messageAEnvoyer;
 ** *out.device()->seek(0);
 ** *out << (quint16) (paquet.size() - sizeof(quint16));
 
 ** *socket->write(paquet); // On envoie le paquet
 }
 
 void FenClient::on_haut_clicked()
 {
 ** *QByteArray paquet;
 ** *QDataStream out(&paquet, QIODevice::WriteOnly);
 
 ** *QString messageAEnvoyer = "cord+" + pseudo->text() + "+" + QString::number(x(0, 0)) + "+" + QString::number(y(0, 1));
 
 ** *out << (quint16) 0;
 ** *out << messageAEnvoyer;
 ** *out.device()->seek(0);
 ** *out << (quint16) (paquet.size() - sizeof(quint16));
 
 ** *socket->write(paquet); // On envoie le paquet
 }
 
 void FenClient::on_bas_clicked()
 {
 ** *QByteArray paquet;
 ** *QDataStream out(&paquet, QIODevice::WriteOnly);
 
 ** * * *QString messageAEnvoyer = "cord+" + pseudo->text() + "+" + QString::number(x(0, 0)) + "+" + QString::number(y(1, 0));
 
 ** *out << (quint16) 0;
 ** *out << messageAEnvoyer;
 ** *out.device()->seek(0);
 ** *out << (quint16) (paquet.size() - sizeof(quint16));
 
 ** *socket->write(paquet); // On envoie le paquet
 }
 
 void FenClient::donneesRecues()
 
 
 ** *QDataStream in(socket);
 
 ** *if (tailleMessage == 0)
 ** *{
 ** * * *if (socket->bytesAvailable() < (int)sizeof(quint16))
 ** * * * * * return;
 
 ** * * *in >> tailleMessage;
 ** *}
 
 ** *if (socket->bytesAvailable() < tailleMessage)
 ** * * *return;
 
 
 *
 ** *QString messageRecu;
 ** *in >> messageRecu;
 ** *QStringList list = QString(messageRecu).split("+");
 ** *if (list[0] == "new")
 ** *{
 ** * * *QLabel *labelt = new QLabel(this);
 ** * * *labelt->setGeometry(QRect(list[2].toInt(), list[3].toInt(), 31, 31));
 ** * * *labelt->setPixmap(QPixmap(QString::fromUtf8("jeu.gif")));
 ** * * *player << list[1];
 ** * * *imgpl << labelt;
 ** * * *//label->setGeometry(QRect(list[2].toInt(), list[3].toInt(), 31, 31));
 ** * * *//label->setPixmap(QPixmap(QString::fromUtf8("jeu.bmp")));
 ** *}
 ** *if (list[0] == "cord")
 ** *{
 ** * * *int m;
 ** * * *m = 0;
 ** *while (player[m] != list[1])
 ** * * *m++;
 
 ** *QLabel *joueur = imgpl.at(m);
 ** *joueur->setGeometry(QRect(list[2].toInt(), list[3].toInt(), 31, 31));
 ** *joueur->setPixmap(QPixmap(QString::fromUtf8("jeu.gif")));
 ** *}
 ** *listeMessages->append(messageRecu);
 ** *tailleMessage = 0;
 }
 int FenClient::x(int plus, int moin)
 {
 ** *static int x = 200;
 ** *if (plus == 1)
 ** *x++;
 ** * else if (moin == 1)
 ** *x--;
 ** *return (x);
 }
 
 int FenClient::y(int plus, int moin)
 {
 ** *static int y = 200;
 ** *if (plus == 1)
 ** *y++;
 ** * else if (moin == 1)
 ** *y--;
 ** *return (y);
 
 }
 
 void FenClient::connecte()
 {
 ** *listeMessages->append(tr("<em>Connexion réussie !</em>"));
 ** *connexion->setEnabled(true);
 ** *QByteArray paquet;
 ** *QDataStream out(&paquet, QIODevice::WriteOnly);
 
 ** *QString messageAEnvoyer = "new+" + pseudo->text() + "+" + QString::number(x(0, 0)) + "+" + QString::number(x(0, 0));
 
 ** *out << (quint16) 0;
 ** *out << messageAEnvoyer;
 ** *out.device()->seek(0);
 ** *out << (quint16) (paquet.size() - sizeof(quint16));
 
 ** *socket->write(paquet); // On envoie le paquet
 }
 void FenClient::deconnecte()
 {
 ** *listeMessages->append(tr("<em>Déconnecté du serveur</em>"));
 }
 
 void FenClient::erreurSocket(QAbstractSocket::SocketError erreur)
 {
 ** *switch(erreur) // On affiche un message différent selon l'erreur qu'on nous indique
 ** *{
 ** * * *case QAbstractSocket::HostNotFoundError:
 ** * * * * *listeMessages->append(tr("<em>ERREUR : le serveur n'a pas pu être trouvé. Vérifiez l'IP et le port.</em>"));
 ** * * * * *break;
 ** * * *case QAbstractSocket::ConnectionRefusedError:
 ** * * * * *listeMessages->append(tr("<em>ERREUR : le serveur a refusé la connexion. Vérifiez si le programme \"serveur\" a bien été lancé. Vérifiez aussi l'IP et le port.</em>"));
 ** * * * * *break;
 ** * * *case QAbstractSocket::RemoteHostClosedError:
 ** * * * * *listeMessages->append(tr("<em>ERREUR : le serveur a coupé la connexion.</em>"));
 ** * * * * *break;
 ** * * *default:
 ** * * * * *listeMessages->append(tr("<em>ERREUR : ") + socket->errorString() + tr("</em>"));
 ** *}
 
 ** *connexion->setEnabled(true);
 }

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
 
 #ifndef UI_FENCLIENT_H
 #define UI_FENCLIENT_H
 
 #include <QtCore/QVariant>
 #include <QtGui/QAction>
 #include <QtGui/QApplication>
 #include <QtGui/QButtonGroup>
 #include <QtGui/QFrame>
 #include <QtGui/QHeaderView>
 #include <QtGui/QLabel>
 #include <QtGui/QLineEdit>
 #include <QtGui/QPushButton>
 #include <QtGui/QTextEdit>
 #include <QtGui/QWidget>
 
 QT_BEGIN_NAMESPACE
 
 class Ui_FenClient
 {
 public:
 ** *QPushButton *connexion;
 ** *QPushButton *haut;
 ** *QPushButton *droite;
 ** *QPushButton *bas;
 ** *QPushButton *gauche;
 ** *QFrame *line;
 ** *QTextEdit *listeMessages;
 ** *QLabel *label;
 ** *QLabel *label_2;
 ** *QLineEdit *pseudo;
 
 ** *void setupUi(QWidget *FenClient)
 ** *{
 ** * * *if (FenClient->objectName().isEmpty())
 ** * * * * *FenClient->setObjectName(QString::fromUtf8("FenClient"));
 ** * * *FenClient->resize(644, 626);
 ** * * *connexion = new QPushButton(FenClient);
 ** * * *connexion->setObjectName(QString::fromUtf8("connexion"));
 ** * * *connexion->setGeometry(QRect(20, 10, 91, 51));
 ** * * *haut = new QPushButton(FenClient);
 ** * * *haut->setObjectName(QString::fromUtf8("haut"));
 ** * * *haut->setGeometry(QRect(340, 20, 61, 51));
 ** * * *droite = new QPushButton(FenClient);
 ** * * *droite->setObjectName(QString::fromUtf8("droite"));
 ** * * *droite->setGeometry(QRect(400, 70, 61, 51));
 ** * * *bas = new QPushButton(FenClient);
 ** * * *bas->setObjectName(QString::fromUtf8("bas"));
 ** * * *bas->setGeometry(QRect(340, 120, 61, 51));
 ** * * *gauche = new QPushButton(FenClient);
 ** * * *gauche->setObjectName(QString::fromUtf8("gauche"));
 ** * * *gauche->setGeometry(QRect(280, 70, 61, 51));
 ** * * *line = new QFrame(FenClient);
 ** * * *line->setObjectName(QString::fromUtf8("line"));
 ** * * *line->setGeometry(QRect(70, 190, 521, 21));
 ** * * *line->setFrameShape(QFrame::HLine);
 ** * * *line->setFrameShadow(QFrame::Sunken);
 ** * * *listeMessages = new QTextEdit(FenClient);
 ** * * *listeMessages->setObjectName(QString::fromUtf8("listeMessages"));
 ** * * *listeMessages->setGeometry(QRect(30, 70, 211, 101));
 ** * * *label_2 = new QLabel(FenClient);
 ** * * *label = new QLabel(FenClient);
 ** * * *label->setObjectName(QString::fromUtf8("label"));
 ** * * *label->setGeometry(QRect(150, 290, 31, 31));
 ** * * *label->setPixmap(QPixmap(QString::fromUtf8("jeu.gif")));
 ** * * *pseudo = new QLineEdit(FenClient);
 ** * * *pseudo->setObjectName(QString::fromUtf8("pseudo"));
 ** * * *pseudo->setGeometry(QRect(130, 20, 113, 20));
 
 ** * * *retranslateUi(FenClient);
 
 ** * * *QMetaObject::connectSlotsByName(FenClient);
 ** *} // setupUi
 
 ** *void retranslateUi(QWidget *FenClient)
 ** *{
 ** * * *FenClient->setWindowTitle(QApplication::translate("FenClient", "Form", 0, QApplication::UnicodeUTF8));
 ** * * *connexion->setText(QApplication::translate("FenClient", "Connexion", 0, QApplication::UnicodeUTF8));
 ** * * *haut->setText(QApplication::translate("FenClient", "Haut", 0, QApplication::UnicodeUTF8));
 ** * * *droite->setText(QApplication::translate("FenClient", "Droite", 0, QApplication::UnicodeUTF8));
 ** * * *bas->setText(QApplication::translate("FenClient", "Bas", 0, QApplication::UnicodeUTF8));
 ** * * *gauche->setText(QApplication::translate("FenClient", "Gauche", 0, QApplication::UnicodeUTF8));
 ** * * *label->setText(QString());
 ** *} // retranslateUi
 
 };
 
 namespace Ui {
 ** *class FenClient: public Ui_FenClient {};
 } // namespace Ui
 
 QT_END_NAMESPACE
 
 #endif // UI_FENCLIENT_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
 
 #ifndef HEADER_FENCLIENT
 #define HEADER_FENCLIENT
 
 #include <QtGui>
 #include <QtNetwork>
 #include "ui_FenClient.h"
 
 
 class FenClient : public QWidget, private Ui::FenClient
 {
     Q_OBJECT
 
     public:
         FenClient();
 
     private slots:
         void on_connexion_clicked();
         void on_haut_clicked();
         void on_bas_clicked();
         void on_droite_clicked();
         int y(int plus, int moin);
         int x(int plus, int moin);
         void on_gauche_clicked();
         void donneesRecues();
         void connecte();
         void deconnecte();
         void erreurSocket(QAbstractSocket::SocketError erreur);
 
     private:
         QTcpSocket *socket; // Représente le serveur
         quint16 tailleMessage;
         QList<QString> player;
         QList<QLabel*> imgpl;
 };
 
 #endif

Voilà, cordialement.

Salut,

J'ai parcouru ton truc en diagonale, si j'ai bien compris tu ajoutes un label quand un joueur se connecte, ou tu modifies un label existant si le joueur est déja connecté.

Par contre je ne vois jamais de "show()" sur tes labels. Ca pourrait aider, non ;) ?

G.

Bonjour,
Merci pour la réponse,
En faite je souhaite qu'un nouveau QLabel soit créer pour chaque nouvelle personne connectée. Et quand cette personne fait une action, ce QLabel se modifie.
Je test ca tout de suite pour le show,

NIKEL ca marche ^^ merci bien :ccool: Si j'ai d'autre problèmes je vous en fait part.

Cordialement

Bonjour,
J'ai une petite question, quelle est le contraire de show()? car après l'avoir afficher, je voudrais la supprimer.
J'ai attribué à Pixmap une image inexistante, ca marche mais c'est pas très propre.
Cordialement

Bonjour,

L'instruction clear() de la class QLabel ...

Citation:

void QLabel::clear () [slot]

Clears any label contents.

Voici une adresse utile :

http://qt.developpez.com/doc/4.6/qlabel/

...

Merci beaucoup^^

Le contraire du show() est hide().

Hide() fait disparaître de l'écran, mais ne modifie pas le contenu. Clear() supprime le contenu, mais je ne pense pas que cela le fasse disparaître de l'écran (si tu avais un couleur de fond sur ton label par exemple, tu la verrais encore).

G.