Discussion :

[Tibà22]

Bonjour à tous, je code actuellement un petit tchat pour permettre la communication en réseau local ou sur le WAN. Tout fonctionne bien lorsque je clique sur le bouton 'Envoyer', le client envoie le message au serveur et le serveur renvoie le message a tous les clients, message qui s'affiche dans un QTextBox.

Il reste un petit truc qui va pas (ca doit être tout con mais je le vois pas): Lorsque je clique sur le bouton Confirmer, pour envoyer le pseudo au serveur, je récupère le pseudo mais dans la liste des messages, or je voudrai qu'il aille dans la liste prévue a cet effet...

Voici mon code:

FenClient.h

Code :

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

1
2
3
4
5
6
7
private slots:
        void donneesRecues();
	void pseudoRecu();
	void confirmation();
private:
        quint16 tailleMessage;
	quint16 taillePseudo;

FenClient.cpp

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
FenClient::FenClient()
{
    connect(boutonConfirmer, SIGNAL(clicked()), this, SLOT(confirmation()));
}
 
void FenClient::confirmation()
{
    QByteArray paquetPseudo;
    QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
 
    QString pseudoAEnvoyer = tr("<strong>") + pseudo->text();
 
    outPseudo << (quint16) 0;
    outPseudo << pseudoAEnvoyer;
    outPseudo.device()->seek(0);
    outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));
 
    socket->write(paquetPseudo); // On envoie le paquet
 
    pseudo->setEnabled(false); // On grise le champs du pseudo
    boutonConfirmer->setEnabled(false); //On grise le bouton de confirmation
}
 
 
// Envoi d'un message au serveur
void FenClient::on_boutonEnvoyer_clicked()
{
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
 
    // On prépare le paquet à envoyer
    QString messageAEnvoyer = tr("<strong>") + pseudo->text() +tr("</strong> : ") + message->text();
 
    out << (quint16) 0;
    out << messageAEnvoyer;
    out.device()->seek(0);
    out << (quint16) (paquet.size() - sizeof(quint16));
 
    socket->write(paquet); // On envoie le paquet
 
    message->clear(); // On vide la zone d'écriture du message
    message->setFocus(); // Et on remet le curseur à l'intérieur
}
 
 
void FenClient::pseudoRecu()
{
 
    /* Même principe que lorsque le serveur reçoit un paquet :
    On essaie de récupérer la taille du pseudo
    Une fois qu'on l'a, on attend d'avoir reçu le pseudo entier (en se basant sur la taille annoncée taillePseudo)
    */
    QDataStream inPseudo(socket);
 
    if (taillePseudo == 0)
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;
 
        inPseudo >> taillePseudo;
    }
 
    if (socket->bytesAvailable() < taillePseudo)
        return;
 
 
    // Si on arrive jusqu'à cette ligne, on peut récupérer le pseudo entier
    QString pseudoRecu;
    inPseudo >> pseudoRecu;
 
     //On affiche le pseudo sur la zone prévue
    listPseudo->append(pseudoRecu);
}
 
void FenClient::donneesRecues()
{
    /* Même principe que lorsque le serveur reçoit un paquet :
    On essaie de récupérer la taille du message
    Une fois qu'on l'a, on attend d'avoir reçu le message entier (en se basant sur la taille annoncée tailleMessage)
    */
    QDataStream in(socket);
 
    if (tailleMessage == 0)
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;
 
        in >> tailleMessage;
    }
 
    if (socket->bytesAvailable() < tailleMessage)
        return;
 
 
    // Si on arrive jusqu'à cette ligne, on peut récupérer le message entier
    QString messageRecu;
    in >> messageRecu;
 
    // On affiche le message sur la zone de Chat
    listeMessages->append(messageRecu);
 
    // On remet la taille du message à 0 pour pouvoir recevoir de futurs messages
    tailleMessage = 0;
}

FenServeur.h

Code :

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

1
2
3
4
5
6
public:
        void envoyerATous(const QString &message);
	void envoyerPseudoATous(const QString &pseudo);
private:
        quint16 tailleMessage;
	quint16 taillePseudo;

FenServeur.cpp

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
//on recoit le pseudo
void FenServeur::pseudoRecu()
{
 
    // 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
 
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
        return;
 
    QDataStream inPseudo(socket); // Si tout va bien, on continue : on lit ce que contient la socketPseudo
 
    if (taillePseudo == 0) // Si on ne connaît pas encore la taille du pseudo, on essaie de la récupérer
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du pseudo en entier
             return;
 
        inPseudo >> taillePseudo; // Si on a reçu la taille du pseudo en entier, on la récupère
    }
 
    // Si on connaît la taille du pseudo, on vérifie si on a reçu le message en entier
    if (socket->bytesAvailable() < taillePseudo) // Si on n'a pas encore tout reçu, on arrête la méthode
        return;
 
    // Si ces lignes s'exécutent, c'est qu'on a reçu tout le pseudo : on peut le récupérer !
    QString pseudo;
    inPseudo >> pseudo;
 
    // 2 : on renvoie le message à tous les clients
    envoyerPseudoATous(pseudo);
 
}
 
//On recoit un message
void FenServeur::donneesRecues()
{
    // 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
 
    // On détermine quel client envoie le message (recherche du QTcpSocket du client)
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
        return;
 
    // Si tout va bien, on continue : on récupère le message
    QDataStream in(socket);
 
    if (tailleMessage == 0) // Si on ne connaît pas encore la taille du message, on essaie de la récupérer
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du message en entier
             return;
 
        in >> tailleMessage; // Si on a reçu la taille du message en entier, on la récupère
    }
 
    // Si on connaît la taille du message, on vérifie si on a reçu le message en entier
    if (socket->bytesAvailable() < tailleMessage) // Si on n'a pas encore tout reçu, on arrête la méthode
        return;
 
 
    // Si ces lignes s'exécutent, c'est qu'on a reçu tout le message : on peut le récupérer !
    QString message;
    in >> message;
 
 
    // 2 : on renvoie le message à tous les clients
    envoyerATous(message);
 
    // 3 : remise de la taille du message à 0 pour permettre la réception des futurs messages
    tailleMessage = 0;
}
 
//Envoi du pseudo a tous le monde
void FenServeur::envoyerPseudoATous(const QString &pseudo)
{
         QByteArray paquetPseudo;
   	 QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
 
   	 // Calcul de la taille du pseudo
   	 outPseudo << (quint16) 0;
   	 outPseudo << pseudo;
    	 outPseudo.device()->seek(0);
      	 outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));
 
   	 // Envoi du paquet préparé à tous les clients connectés au serveur
    	for (int i = 0; i < clients.size(); i++)
    	{
   	    clients[i]->write(paquetPseudo);
	}
}
 
void FenServeur::envoyerATous(const QString &message)
{
    // Préparation du paquet
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
 
    //Calcul de la taille du paquet
    out << (quint16) 0; // On écrit 0 au début du paquet pour réserver la place pour écrire la taille
    out << message; // On ajoute le message à la suite
    out.device()->seek(0); // On se replace au début du paquet
    out << (quint16) (paquet.size() - sizeof(quint16)); // On écrase le 0 qu'on avait réservé par la longueur du message
 
 
    // Envoi du paquet préparé à tous les clients connectés au serveur
    for (int i = 0; i < clients.size(); i++)
    {
        clients[i]->write(paquet);
    }
}

Voila, je conclu qu'il ne différencie pas l'envoi d'un pseudo de l'envoi d'un message, j'ai essayé pas mal de trucs mais rien ne fonctionne... je sens que c'est très proche!

Une idée??

Merci!

[Tibà22]

J'ai remarqué que le programme ne rentre pas dans la fonction pseudoRecu()

j'ai donc décidé de tout traiter dans donneesRecues() et c'est le même problème, je n'arrive pas a comparer le paquet pseudo du paquet message, il met donc tout dans la liste des messages...

[Tibà22]

Pour l'instant j'ai fais ca pour le pseudo, voici les problèmes:
je clique sur le bouton "Confirmer", je recois "codePseudo" dans les 2 listes
je saisie un message, je clique sur "envoyer" et je ne reçois rien, sauf quand je clique une 2eme fois sur "Envoyer" il me renvoie "codeMessage" à chaque clic

Ca y est presque, quelqu'un aurait une idée pour corriger ca?

FenClient.cpp

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
//Confirmation, envoi du pseudo au serveur
void FenClient::confirmation()
{
 
    QString codePseudo = "codePseudo";
    QByteArray paquetPseudo;
    QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
    QString pseudoAEnvoyer = tr("<strong>") + pseudo->text();
 
    outPseudo << (quint16) 0;// On écrit 0 au début du paquet pour réserver la place pour écrire la taille
    outPseudo << pseudoAEnvoyer;// On ajoute le pseudo à la suite
    outPseudo.device()->seek(0);// On se replace au début du paquet
    outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));
    outPseudo << codePseudo;
 
 
    socket->write(paquetPseudo); // On envoie le paquet
 
    pseudo->setEnabled(false); // On grise le champs du pseudo
    boutonConfirmer->setEnabled(false); //On grise le bouton de confirmation
}
 
 
 
 
// Envoi d'un message au serveur
void FenClient::on_boutonEnvoyer_clicked()
{
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
    QString codeMessage = "codeMessage";
    // On prépare le paquet à envoyer
    QString messageAEnvoyer = tr("<strong>") + pseudo->text() +tr("</strong> : ") + message->text();
 
    out << (quint16) 0;
    out << messageAEnvoyer;
    out.device()->seek(0);
    out << (quint16) (paquet.size() - sizeof(quint16));
    out << codeMessage;
 
    socket->write(paquet); // On envoie le paquet
 
    message->clear(); // On vide la zone d'écriture du message
    message->setFocus(); // Et on remet le curseur à l'intérieur
}
 
// On a reçu un paquet (ou un sous-paquet)
void FenClient::donneesRecues()
{
 
/* Même principe que lorsque le serveur reçoit un paquet :
    On essaie de récupérer la taille du message
    Une fois qu'on l'a, on attend d'avoir reçu le message entier (en se basant sur la taille annoncée tailleMessage)
    */
    QDataStream in(socket);
 
    if (tailleMessage == 0)
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;
 
        in >> tailleMessage;
    }
 
    if (socket->bytesAvailable() < tailleMessage)
        return;
 
 
    // Si on arrive jusqu'à cette ligne, on peut récupérer le message entier
    QString messageRecu;
    in >> messageRecu;
 
    if (messageRecu.endsWith("codePseudo")) //si le paquet contient "codePseudo"
      listPseudo->append(messageRecu); //on affiche le paquet dans la liste de pseudo
 
 
    if (messageRecu.endsWith("codeMessage"));
    listeMessages->append(messageRecu); //on affiche le paquet dans la zone des messages
 
    // On remet la taille du message à 0 pour pouvoir recevoir de futurs messages
    tailleMessage = 0;
 
}

FenServeur.cpp

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
void FenServeur::donneesRecues()
{
// 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
 
    // On détermine quel client envoie le message (recherche du QTcpSocket du client)
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
        return;
 
    // Si tout va bien, on continue : on récupère le message
    QDataStream in(socket);
 
    if (tailleMessage == 0) // Si on ne connaît pas encore la taille du message, on essaie de la récupérer
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du message en entier
             return;
 
        in >> tailleMessage; // Si on a reçu la taille du message en entier, on la récupère
    }
 
    // Si on connaît la taille du message, on vérifie si on a reçu le message en entier
    if (socket->bytesAvailable() < tailleMessage) // Si on n'a pas encore tout reçu, on arrête la méthode
        return;
 
 
    // Si ces lignes s'exécutent, c'est qu'on a reçu tout le message : on peut le récupérer !
    QString message;
    in >> message;
 
    if (message.endsWith("codePseudo"))
     {
      envoyerPseudoATous(message);
     }
 
    if (message.endsWith("codeMessage"));
     {
      envoyerATous(message);
     }
 
    // 3 : remise de la taille du message à 0 pour permettre la réception des futurs messages
    tailleMessage = 0;
 
 
}
 
 
//Envoi du pseudo a tous le monde
void FenServeur::envoyerPseudoATous(const QString &messagepseudo)
{
         QByteArray paquetPseudo;
   	 QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
	 QString codePseudo = "codePseudo";
   	 // Calcul de la taille du pseudo
   	 outPseudo << (quint16) 0; // On écrit 0 au début du paquet pour réserver la place pour écrire la taille
   	 outPseudo << messagepseudo;// On ajoute le pseudo à la suite
    	 outPseudo.device()->seek(0);// On se replace au début du paquet
      	 outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));// On écrase le 0 qu'on avait réservé par la longueur du pseudo 
         outPseudo << codePseudo;
   	 // Envoi du paquet préparé à tous les clients connectés au serveur
    	for (int i = 0; i < clients.size(); i++)
    	{
   	    clients[i]->write(paquetPseudo);
	}
}
 
 
void FenServeur::envoyerATous(const QString &message)
{
    // Préparation du paquet
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
    QString codeMessage = "codeMessage";
    //Calcul de la taille du paquet
    out << (quint16) 0; // On écrit 0 au début du paquet pour réserver la place pour écrire la taille
    out << message; // On ajoute le message à la suite
    out.device()->seek(0); // On se replace au début du paquet
    out << (quint16) (paquet.size() - sizeof(quint16)); // On écrase le 0 qu'on avait réservé par la longueur du message
    out << codeMessage;
 
    // Envoi du paquet préparé à tous les clients connectés au serveur
    for (int i = 0; i < clients.size(); i++)
    {
        clients[i]->write(paquet);
    }
}

[Amnell]

Bonjour,

Dans la création des paquets, vous faites :

Code :

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

outPseudo.device()->seek(0);// On se replace au début du paquet

Je me trompe peut-être, mais si cela fait qu'on se replace au début du paquet, "codeMessage" ou son confrère seront situé en début de paquet et non en fin de paquet. Ainsi, au lieu d'avoir à utiliser la fonction endsWith, il faudrait plutôt utiliser startsWith.

Bonne continuation,
Amnell.

[Tibà22]

J'ai pas mal avancé, ça marche pas mal, juste quelques soucis qui sont les suivants:

Je clique sur "Confirmer" pour envoyer le pseudo, il me le renvoie dans les 2 listes
Je saisi un message, clic sur "Envoyer" et il me renvoie (encore, du coup je l'ai en double) le pseudo dans les 2 listes, si je saisi un nouveau message, il me renvoie le message précédemment saisi dans la liste de messages.

Voici le code:

FenClient.cpp

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
// On a reçu un paquet (ou un sous-paquet)
void FenClient::donneesRecues()
{
 
/* Même principe que lorsque le serveur reçoit un paquet :
    On essaie de récupérer la taille du message
    Une fois qu'on l'a, on attend d'avoir reçu le message entier (en se basant sur la taille annoncée tailleMessage)
    */
    QDataStream in(socket);
 
    if (tailleMessage == 0)
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;
 
        in >> tailleMessage;
    }
 
    if (socket->bytesAvailable() < tailleMessage)
        return;
 
 
    // Si on arrive jusqu'à cette ligne, on peut récupérer le message entier
    QString messageRecu;
    in >> messageRecu;
 
    if (messageRecu.endsWith("0011")) //si le paquet contient "codePseudo"
     {
      messageRecu.remove("0011");
      listPseudo->append(messageRecu); //on affiche le paquet dans la liste de pseudo
     }
 
    if (messageRecu.endsWith("0022"));
     {
      messageRecu.remove("0022");
      listeMessages->append(messageRecu); //on affiche le paquet dans la zone des messages
 
     }
    // On remet la taille du message à 0 pour pouvoir recevoir de futurs messages
    tailleMessage = 0;
 
}
 
//Confirmation, envoi du pseudo au serveur
void FenClient::confirmation()
{
 
 
    QByteArray paquetPseudo;
    QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
    QString pseudoAEnvoyer = tr("<strong>") + pseudo->text() + " 0011";
 
    outPseudo << (quint16) 0;// On écrit 0 au début du paquet pour réserver la place pour écrire la taille
    outPseudo << pseudoAEnvoyer;// On ajoute le pseudo à la suite
    outPseudo.device()->seek(0);// On se replace au début du paquet
    outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));
 
 
    socket->write(paquetPseudo); // On envoie le paquet
 
    pseudo->setEnabled(false); // On grise le champs du pseudo
    boutonConfirmer->setEnabled(false); //On grise le bouton de confirmation
}
 
// Envoi d'un message au serveur
void FenClient::on_boutonEnvoyer_clicked()
{
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
 
    // On prépare le paquet à envoyer
    QString messageAEnvoyer = tr("<strong>") + pseudo->text() +tr("</strong> : ") + message->text() + "0022";
 
    out << (quint16) 0;
    out << messageAEnvoyer;
    out.device()->seek(0);
    out << (quint16) (paquet.size() - sizeof(quint16));
 
 
 
    socket->write(paquet); // On envoie le paquet
 
    message->clear(); // On vide la zone d'écriture du message
    message->setFocus(); // Et on remet le curseur à l'intérieur
}

FenServeur.cpp

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
void FenServeur::donneesRecues()
{
// 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
 
    // On détermine quel client envoie le message (recherche du QTcpSocket du client)
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
        return;
 
    // Si tout va bien, on continue : on récupère le message
    QDataStream in(socket);
 
    if (tailleMessage == 0) // Si on ne connaît pas encore la taille du message, on essaie de la récupérer
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du message en entier
             return;
 
        in >> tailleMessage; // Si on a reçu la taille du message en entier, on la récupère
    }
 
    // Si on connaît la taille du message, on vérifie si on a reçu le message en entier
    if (socket->bytesAvailable() < tailleMessage) // Si on n'a pas encore tout reçu, on arrête la méthode
        return;
 
 
    // Si ces lignes s'exécutent, c'est qu'on a reçu tout le message : on peut le récupérer !
    QString message;
    in >> message;
 
    if (message.endsWith("0011"))
     {
      envoyerPseudoATous(message);
     }
 
    if (message.endsWith("0022"));
     {
      envoyerATous(message);
     }
 
    // 3 : remise de la taille du message à 0 pour permettre la réception des futurs messages
    tailleMessage = 0;
 
 
}
 
//Envoi du pseudo a tous le monde
void FenServeur::envoyerPseudoATous(const QString &messagepseudo)
{
         QByteArray paquetPseudo;
   	 QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
   	 // Calcul de la taille du pseudo
   	 outPseudo << (quint16) 0; // On écrit 0 au début du paquet pour réserver la place pour écrire la taille
   	 outPseudo << messagepseudo;// On ajoute le pseudo à la suite
    	 outPseudo.device()->seek(0);// On se replace au début du paquet
      	 outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));// On écrase le 0 qu'on avait réservé par la longueur du pseudo 
 
   	 // Envoi du paquet préparé à tous les clients connectés au serveur
    	for (int i = 0; i < clients.size(); i++)
    	{
   	    clients[i]->write(paquetPseudo);
	}
}
 
 
void FenServeur::envoyerATous(const QString &message)
{
    // Préparation du paquet
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
 
 
    //Calcul de la taille du paquet
    out << (quint16) 0; // On écrit 0 au début du paquet pour réserver la place pour écrire la taille
    out << message; // On ajoute le message à la suite
    out.device()->seek(0); // On se replace au début du paquet
    out << (quint16) (paquet.size() - sizeof(quint16)); // On écrase le 0 qu'on avait réservé pour la longueur du message
 
 
    // Envoi du paquet préparé à tous les clients connectés au serveur
    for (int i = 0; i < clients.size(); i++)
    {
        clients[i]->write(paquet);
    }
}

[Amnell]

Si je comprends bien la question, vous souhaitez supprimer les doublons ?
Dans le cas où listPseudo et l'autre seraient des instances de QStringList, il suffirait d'appeler la fonction removeDuplicates, de mémoire.

[Tibà22]

ce sont des instances de QTextEdit. Supprimer les doublons seraient une chose, mais si il y en a c'est quand même qu'il y a un souci -> je me vois 2 fois dans la liste des connectés alors que je n'ai qu'un client connecté (pour les tests)

[Amnell]

Ce qui semble logique puisque la fonction de confirmation et la fonction d'envoi ont une partie en commun : ils envoient chacun les données (ce qui fait qu'au final, l'un des deux boutons ne sert à rien).

[Tibà22]

O_O ... Je recommence tout, j'te tiens au jus, merci

[Amnell]

O_O ... Je recommence tout, j'te tiens au jus, merci

Bon courage !

[Tibà22]

Bon, j'ai enlevé le bouton "Confirmer", maintenant tout s'envoie par "Envoyer".
Je voudrais en fait, que quand l'utilisateur n'a saisi aucun pseudo, le champs pseudo soit activé (qu'on puisse le remplir) au contraire du champs message.
Et vice versa, si l'utilisateur est "logué" le champ pseudo se grise, et le champs message devient accessible, donc ca c'est fait.

J'ai aussi écrit une fonction qui stocke tous les pseudos connectés dans un .txt.

Maintenant, je me connecte et saisi mon pseudo, il s'affiche bien dans la liste Pseudo (un bon point deja)

Lorsque je tape un message, seul le pseudo s'affiche, et en + dans la liste Pseudo (je voudrai qu'il affiche Pseudo + Message dans la liste des messages!)

Voici mon code

FenClient.cpp

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
// Envoi d'un message au serveur
void FenClient::on_boutonEnvoyer_clicked()
{
    pseudo->setEnabled(false);
    message->setEnabled(true);
 
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
 
 
if (!pseudo==false) //Si le champs Pseudo est actif on envoie que le pseudo
{
    QString messageAEnvoyer = tr("<strong>") + pseudo->text() + "#";
    out << (quint16) 0;
    out << messageAEnvoyer;
    out.device()->seek(0);
    out << (quint16) (paquet.size() - sizeof(quint16));
    socket->write(paquet); // On envoie le paquet
}
 
 
if (!pseudo==true) //si le champs pseudo est inactif, il est deja saisi, on envoie pseudo + message + $
{
    QString messageAEnvoyer = tr("<strong>") + pseudo->text() +tr("</strong> : ") + message->text() + "$";
    out << (quint16) 0;
    out << messageAEnvoyer;
    out.device()->seek(0);
    out << (quint16) (paquet.size() - sizeof(quint16));
    socket->write(paquet); // On envoie le paquet
}
 
    message->clear(); // On vide la zone d'écriture du message
    message->setFocus(); // Et on remet le curseur à l'intérieur
}
 
 
// On a reçu un paquet (ou un sous-paquet)
void FenClient::donneesRecues()
{
 
/* Même principe que lorsque le serveur reçoit un paquet :
    On essaie de récupérer la taille du message
    Une fois qu'on l'a, on attend d'avoir reçu le message entier (en se basant sur la taille annoncée tailleMessage)
    */
    QDataStream in(socket);
 
    if (tailleMessage == 0)
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16))
             return;
 
        in >> tailleMessage;
    }
 
    if (socket->bytesAvailable() < tailleMessage)
        return;
 
 
    // Si on arrive jusqu'à cette ligne, on peut récupérer le message entier
    QString messageRecu;
    in >> messageRecu;
 
    if (messageRecu.endsWith("#")) //si le paquet fini par "#" c'est seulement le pseudo
     {
      messageRecu.remove("#"); //on supprime le caractère #
      listPseudo->append(messageRecu); //on affiche le paquet dans la liste des pseudos
     }
 
 
    if (messageRecu.endsWith("$")) //si le paquet fini par "$" c'est le pseudo + message
     {
      messageRecu.remove("$"); //on supprime le caractère $
      listeMessages->append(messageRecu); //on affiche le paquet dans la liste des messages
     }
 
 
 
    // On remet la taille du message à 0 pour pouvoir recevoir de futurs messages
    tailleMessage = 0;
 
}

FenServeur.cpp

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
void FenServeur::donneesRecues()
{
// 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
 
    // On détermine quel client envoie le message (recherche du QTcpSocket du client)
    QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
    if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
        return;
 
    // Si tout va bien, on continue : on récupère le message
    QDataStream in(socket);
 
    if (tailleMessage == 0) // Si on ne connaît pas encore la taille du message, on essaie de la récupérer
    {
        if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du message en entier
             return;
 
        in >> tailleMessage; // Si on a reçu la taille du message en entier, on la récupère
    }
 
    // Si on connaît la taille du message, on vérifie si on a reçu le message en entier
    if (socket->bytesAvailable() < tailleMessage) // Si on n'a pas encore tout reçu, on arrête la méthode
        return;
 
 
    // Si ces lignes s'exécutent, c'est qu'on a reçu tout le message : on peut le récupérer !
    QString message;
    in >> message;
 
 
     if (message.endsWith("#")) // s'il fini par "#", c'est le pseudo, on l'écrit dans le fichier
     {
	//Création du fichier de stockage des contacts
 
	QFile file("Fichiers//Contacts.txt");// Création d'un objet QFile
 
 
        // On ouvre notre fichier en lecture et écriture et on se place à la fin
 
	if (!file.open(QIODevice::ReadWrite | QIODevice::Text | QIODevice::Append)) 
 
	return;
 
 
	QTextStream flux(&file);// Création d'un objet QTextStream à partir de notre objet QFile
 
	flux.setCodec("UTF-8");// On choisit le codec UTF-8
 
 
 
	// Écriture du pseudo dans le fichier 
 
	flux << QString("%1").arg(message) << endl; 
 
 
      envoyerPseudoATous(message); //on envoi le pseudo a tout le monde
 
     }
 
 
     if (message.endsWith("$")) //si le message fini par "$", c'est le message complet (pseudo+ message)
     {
      envoyerATous(message); //on envoie à tout le monde 
     }
 
 
    // 3 : remise de la taille du message à 0 pour permettre la réception des futurs messages
    tailleMessage = 0;
 
}
 
 
//Envoi du pseudo a tous le monde
void FenServeur::envoyerPseudoATous(const QString &messagepseudo)
{
 
	QFile file("Fichiers//Contacts.txt");
 
 
 
	if (!file.open(QIODevice::ReadOnly)) // On ouvre notre fichier en lecture
 
	return;
 
	QByteArray paquetPseudo = file.readAll(); //on lit tout le fichier
   	QDataStream outPseudo(&paquetPseudo, QIODevice::WriteOnly);
 
   	 // Calcul de la taille du pseudo
   	 outPseudo << (quint16) 0;
   	 outPseudo << messagepseudo;// On ajoute le pseudo à la suite
    	 outPseudo.device()->seek(0);// On se replace au début du paquet
      	 outPseudo << (quint16) (paquetPseudo.size() - sizeof(quint16));// On écrase le 0 qu'on avait réservé par la longueur du pseudo 
 
 
   	 // Envoi du paquet préparé à tous les clients connectés au serveur
    	for (int i = 0; i < clients.size(); i++)
    	{
   	    clients[i]->write(paquetPseudo);
	}
}
 
 
void FenServeur::envoyerATous(const QString &message)
{
    // Préparation du paquet
    QByteArray paquet;
    QDataStream out(&paquet, QIODevice::WriteOnly);
 
 
    //Calcul de la taille du paquet
    out << (quint16) 0; // On écrit 0 au début du paquet pour réserver la place pour écrire la taille
    out << message; // On ajoute le message à la suite
    out.device()->seek(0); // On se replace au début du paquet
    out << (quint16) (paquet.size() - sizeof(quint16)); // On écrase le 0 qu'on avait réservé pour la longueur du message
 
 
    // Envoi du paquet préparé à tous les clients connectés au serveur
    for (int i = 0; i < clients.size(); i++)
    {
        clients[i]->write(paquet);
    }
}

Le fichier quant à lui, se rempli comme suit:

<strong>testPseudo#
<strong>testPseudo#
<strong>testPseudo#
<strong>testPseudo#

une idée?

[Amnell]

Déjà, une petite chose, quand vous faites :

Code :

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

1
2
if (!pseudo==false) { ... }
if (!pseudo==true) { ... }

Vous checkez uniquement si le pointeur a été défini ou non. Il vaudrait mieux remplacer par ceci :

Code :

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

1
2
if (pseudo->isEnabled()) { ... }
if (pseudo->isDisabled()) { ... }

Concernant les pseudos stockés dans le fichier, ce n'est pas très esthétique. Étant tous de la forme <strong>[pseudo]#, on peut l'affiner en faisant ceci :

Code :

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

1
2
3
QString pseudo = /* le pseudo récupéré sous la forme donnée */;
pseudo.chop(1); // Retrait du dernier caractère
pseudo.remove(0, 8); // Retrait des huit premiers caractères

À ce moment, vous aurez un pseudo de la forme [pseudo] tout prêt à être enregistré dans le .txt.

Je voudrais en fait, que quand l'utilisateur n'a saisi aucun pseudo, le champs pseudo soit activé (qu'on puisse le remplir) au contraire du champs message.

Au moment de la construction du champ de message, il suffit de faire un setEnabled(false), puis de faire une connexion du champ de pseudo (QLineEdit ?) de la sorte :

Code :

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

1
2
3
4
5
6
7
8
connect(pseudo, SIGNAL(textChanged(const QString&)), this, SLOT(checkPseudo(const QString&));
 
// ...
 
void checkPseudo(const QString &text)
{
    message->setEnabled(!text.isEmpty());
}

Ainsi, si le texte du champ de pseudo est vide, cela va griser le champ de message, tandis que s'il ne l'est pas, cela va le rendre actif.

Lorsque je tape un message, seul le pseudo s'affiche, et en + dans la liste Pseudo (je voudrai qu'il affiche Pseudo + Message dans la liste des messages!)

Dans votre code, côté serveur, vous avez mis envoyerPseudoATous(message) à la fois quand le message reçu correspond à un pseudo et quand il correspond à un message, d'où le fait que vous ayez ceci, en plus de ce que j'ai dit au début du post.

[Tibà22]

Dans votre code, côté serveur, vous avez mis envoyerPseudoATous(message) à la fois quand le message reçu correspond à un pseudo et quand il correspond à un message, d'où le fait que vous ayez ceci, en plus de ce que j'ai dit au début du post.

Je ne vois pas ce que tu veux dire, peux tu me montrer mon erreur sur le code?

merci

[Amnell]

Vous faites ceci :

Code :

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

1
2
3
4
	// Écriture du pseudo dans le fichier 
	flux << QString("%1").arg(message) << endl; 
      envoyerPseudoATous(message); //on envoi le pseudo a tout le monde 
     }

Mais après réflexion, ça ne doit pas être problématique. Par contre, le reste l'est.

[Tibà22]

J'ai fais ce que tu m'as dis, l'affichage est désormais bon, les pseudos vont dans la listePseudos et les message dans la listeMessages.

Petit souci qui apparait (qui était peut etre la avant mais j'avais peut etre pas fait attention) : je n'ai le droit qu'a 3 clients maximum, autrement dit 3 lignes dans le fichier, et le 3eme client qui se connecte peut envoyer son pseudo, mais pas de messages (ca n'apparait pas ....)

[Amnell]

Comme ça, je ne peux pas vous répondre. clients est un QVector<QTcpSocket *> ?

[Tibà22]

Non, clients est une QList<QTcpSocket *>

[Amnell]

Pour le coup, je laisse la main.

Quoi qu'il en soit, vous en êtes déjà arrivé assez loin, et l'erreur ne doit pas être si terrible que ça. En plaçant des logs dans le code, cela devrait permettre de trouver l'origine du problème.

Bonne continuation,
Amnell.

[Tibà22]

Merci à vous pour l'aide en tout cas, ca m'a beaucoup aidé et j'espère que ca en aidera d'autres

Bonne soirée !!

Tib

[Amnell]

À noter que si vous trouvez le dernier élément pour clore votre demande, il faudra indiquer que le sujet est résolu en cliquant sur le bouton associé.

Bonne soirée,
Amnell.