Russian Qt Forum

#include <QApplication>
#include "humanclient.h"

int main(int argc, char **argv)
{   QApplication app(argc, argv);
    HumanClient client("localhost", 1516);

    client.show();
    return app.exec();
}----------------------------------
#ifndef HUMANCLIENT_H
#define HUMANCLIENT_H

#include <QWidget>
#include <QTcpSocket>
#include "seamap.h"

class QTextEdit;
class QLineEdit;
class QPushButton;
class QLabel;

class HumanClient : public QWidget
{
Q_OBJECT
private:
    QTcpSocket *tcpSocket;
    QTextEdit *textInfo;
    QLineEdit *textInput;
    QPushButton *sendButton;
    QPushButton *sendMapButton;
    QPushButton *eraseMapButton;
    QLabel *myLabel;
    QLabel *enemyLabel;
    quint16 nextBlockSize;
    SeaMap *firstMap;
    SeaMap *secondMap;

public:
    HumanClient(const QString& host, int port, QWidget *parent = 0);
    ~HumanClient();

signals:

public slots:
    void slotReadyRead();
    void slotError(QAbstractSocket::SocketError);
    void slotSendToServer();
    void slotSendMap();
    void slotEraseMap();
};
------------------------------------
#include "humanclient.h"
#include <QString>
#include <QLabel>
#include <QTextEdit>
#include <QLineEdit>
#include <QRegExp>
#include <QRegExpValidator>
#include <QAbstractSocket>
#include <QLayout>
#include <QByteArray>
#include <QDataStream>
#include <QPushButton>
#include <QTextCodec>

HumanClient::HumanClient(const QString& host,
			 int port,
			 QWidget *parent) :
    QWidget(parent), nextBlockSize(0)

{
    QTextCodec *codePage = QTextCodec::codecForName("CP1251");
    QTextCodec::setCodecForTr(codePage);
    QTextCodec::setCodecForCStrings(codePage);
    QTextCodec::setCodecForLocale(codePage);

    tcpSocket = new QTcpSocket(this);
    textInfo = new QTextEdit(this);
    textInput = new QLineEdit(this);
    firstMap = new SeaMap(this);
    secondMap = new SeaMap(this);
    sendButton = new QPushButton("Огонь!", this);
    sendMapButton = new QPushButton("Отправить карту", this);
    eraseMapButton = new QPushButton("Очистить карту", this);
    myLabel = new QLabel("Моя карта", this);
    enemyLabel = new QLabel("Карта противника", this);

    sendButton->setEnabled(false);

    tcpSocket->connectToHost(host, port);
    textInfo->setReadOnly(true);

    QRegExp regExp("[A-J]([1-9]|[1][0])");
    textInput->setValidator(new QRegExpValidator(regExp, this));

    firstMap->setEnemy(false);
    secondMap->setEnemy(true);

    connect(tcpSocket, SIGNAL(readyRead()), SLOT(slotReadyRead()));
    connect(tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
	    this, SLOT(slotError(QAbstractSocket::SocketError)));

    connect(sendButton, SIGNAL(clicked()), SLOT(slotSendToServer()));
    connect(sendMapButton, SIGNAL(clicked()),
	    this, SLOT(slotSendMap()));
    connect(eraseMapButton, SIGNAL(clicked()),
	    this, SLOT(slotEraseMap()));

    connect(secondMap, SIGNAL(seaCoord(const QString&)),
	    textInput, SLOT(setText(const QString&)));

    QVBoxLayout *vBoxLayout = new QVBoxLayout;
    vBoxLayout->addWidget(new QLabel("<H1>Клиент</H1>"));
    vBoxLayout->addWidget(textInfo);
    vBoxLayout->addWidget(textInput);
    vBoxLayout->addWidget(sendButton);
    vBoxLayout->addWidget(sendMapButton);

    QVBoxLayout *firstFieldLayout = new QVBoxLayout;
    firstFieldLayout->addWidget(firstMap);
    firstFieldLayout->addWidget(myLabel);
    firstFieldLayout->addWidget(eraseMapButton);
    firstFieldLayout->addStretch(1);

    QVBoxLayout *secondFieldLayout = new QVBoxLayout;
    secondFieldLayout->addWidget(secondMap);
    secondFieldLayout->addWidget(enemyLabel);
    secondFieldLayout->addStretch(1);

    QHBoxLayout *mainLayout = new QHBoxLayout(this);
    mainLayout->addLayout(vBoxLayout);
    mainLayout->addLayout(firstFieldLayout);
    mainLayout->addLayout(secondFieldLayout);

    setLayout(mainLayout);
}

HumanClient::~HumanClient()
{   tcpSocket->disconnectFromHost();
}


void HumanClient::slotReadyRead()
{   QDataStream input(tcpSocket);
    QString str;
    quint16 type = 0;

    input.setVersion(QDataStream::Qt_4_6);
    for (;;)
    {	if (!nextBlockSize)
	{   if (tcpSocket->bytesAvailable() < sizeof(quint16))
		break;
	    input >> nextBlockSize;
	}

	if (tcpSocket->bytesAvailable() < nextBlockSize)
	    break;

	if (!type)
	{   if (tcpSocket->bytesAvailable() < sizeof(quint16))
		break;
	    input >> type;
	}

	if (type == 3)
	{   input >> str;
	    textInfo->append(str);
	}
	nextBlockSize = 0;
    }
}

void HumanClient::slotError(QAbstractSocket::SocketError error)
{   QString strError;

    strError = "Ошибка: " + (error == QAbstractSocket::HostNotFoundError ?
			    "Хост не найден." :
			    error == QAbstractSocket::RemoteHostClosedError ?
			    "Удалённый хост закрыт." :
			    error == QAbstractSocket::ConnectionRefusedError ?
			    "Отказано в соединении." :
			    QString(tcpSocket->errorString()));
    textInfo->append(strError);
}

void HumanClient::slotSendToServer()
{   QByteArray block;
    QDataStream output(&block, QIODevice::WriteOnly);

    output.setVersion(QDataStream::Qt_4_6);
    output << quint16(0) << quint16(1) << textInput->text();
    output.device()->seek(0);
    output << quint16(block.size() - sizeof(quint16));

    tcpSocket->write(block);
    textInput->setText("");
}

void HumanClient::slotSendMap()
{   QByteArray block;
    QDataStream output(&block, QIODevice::WriteOnly);
    quint8 i, j;

    output.setVersion(QDataStream::Qt_4_6);
    output << quint16(0) << quint16(2);

    for (i = 1; i < 11; i++)
	for (j = 1; j < 11; j++)
	{   output << quint16(firstMap->getCell(i, j));
	}

    output.device()->seek(0);
    output << quint16(block.size() - sizeof(quint16));
    tcpSocket->write(block);
}

void HumanClient::slotEraseMap()
{   firstMap->eraseMap();
    update();
}
-------------------------------------