fenclient.cpp

#include "fenclient.h"

FenClient::FenClient()
{
    infoServ = new QHBoxLayout;
    infoClient = new QHBoxLayout;
    layout = new QVBoxLayout;

    ip = new QLabel;
    ip->setText("Ip du serveur: ");
    port = new QLabel;
    port->setText("Port du serveur: ");
    pseudoLabel = new QLabel;
    pseudoLabel->setText("Pseudo: ");
    messageLabel = new QLabel;
    messageLabel->setText("Message: ");

    listeMessages = new QTextEdit;
    boutonConnexion = new QPushButton;
    boutonConnexion->setText("Connexion!");
    boutonEnvoyer = new QPushButton;
    boutonEnvoyer->setText("Envoyer!");
    serveurPort = new QSpinBox;
    serveurIP = new QLineEdit;
    pseudo = new QLineEdit;
    message = new QLineEdit;

    infoServ->addWidget(ip);
    infoServ->addWidget(serveurIP);
    infoServ->addWidget(port);
    infoServ->addWidget(serveurPort);
    infoServ->addWidget(boutonConnexion);

    infoClient->addWidget(pseudoLabel);
    infoClient->addWidget(pseudo);
    infoClient->addWidget(messageLabel);
    infoClient->addWidget(message);
    infoClient->addWidget(boutonEnvoyer);

    layout->addLayout(infoServ);
    layout->addWidget(listeMessages);
    layout->addLayout(infoClient);
    setLayout(layout);

    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)));
    connect(boutonConnexion, SIGNAL(clicked(bool)), this, SLOT(on_boutonConnexion_clicked()));
    connect(boutonEnvoyer, SIGNAL(clicked(bool)), this, SLOT(on_boutonEnvoyer_clicked()));
    connect(message, SIGNAL(returnPressed()), this, SLOT(on_boutonEnvoyer_clicked()));

    tailleMessage = 0;
}

// Tentative de connexion au serveur
void FenClient::on_boutonConnexion_clicked()
{
    // On annonce sur la fenêtre qu'on est en train de se connecter
    listeMessages->append(tr("<em>Tentative de connexion en cours...</em>"));
    boutonConnexion->setEnabled(false);

    socket->abort(); // On désactive les connexions précédentes s'il y en a
    socket->connectToHost(serveurIP->text(), serveurPort->value()); // On se connecte au serveur demandé
}

// 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
}

// Appuyer sur la touche Entrée a le même effet que cliquer sur le bouton "Envoyer"
void FenClient::on_message_returnPressed()
{
    on_boutonEnvoyer_clicked();
}

// 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;

    // 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;
}

// Ce slot est appelé lorsque la connexion au serveur a réussi
void FenClient::connecte()
{
    listeMessages->append(tr("<em>Connexion réussie !</em>"));
    boutonConnexion->setEnabled(true);
}

// Ce slot est appelé lorsqu'on est déconnecté du serveur
void FenClient::deconnecte()
{
    listeMessages->append(tr("<em>Déconnecté du serveur</em>"));
}

// Ce slot est appelé lorsqu'il y a une erreur
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>"));
    }

    boutonConnexion->setEnabled(true);
}