class QRailItem : public QObject, public QGraphicsItem
{
    Q_OBJECT
    Q_INTERFACES (QGraphicsItem)
public:
    virtual     void    loadFromStream(QDomDocument * doc,QDomElement * node);
    virtual     void    saveToStream(QDomDocument * doc,QDomElement * node);
};

void    QRailItem::loadFromStream(QDomDocument * /*doc*/, QDomElement * node)
{
    QDomElement railItemNode = node->firstChildElement("RailItemData"); //нода класса QRailItem
    if(!railItemNode.isNull())
    {
        bool    ok;
        QPointF pos;
        id = railItemNode.attribute("ObjectID","0").toLong(&ok);
        setRotation(railItemNode.attribute("Angle").toFloat(&ok));
        pos.setX(railItemNode.attribute("PosX").toFloat(&ok));
        pos.setY(railItemNode.attribute("PosY").toFloat(&ok));
        this->setPos(pos);
        setZValue(railItemNode.attribute("ZValue","0").toFloat(&ok));
    }
}

void    QRailItem::saveToStream(QDomDocument * doc, QDomElement * node)
{
    QDomElement railItemNode = doc->createElement("RailItemData"); //создаю ноду класса QRailItem
    railItemNode.setAttribute("ObjectID",id);
    railItemNode.setAttribute("PosX",pos().x());
    railItemNode.setAttribute("PosY",pos().y());
    railItemNode.setAttribute("Angle",rotation());
    railItemNode.setAttribute("ZValue",zValue());
    node->appendChild(railItemNode);
}

class QSection: public QRailItem
{
    Q_OBJECT
public:
    void            loadFromStream(QDomDocument * doc,QDomElement * node);
    void            saveToStream(QDomDocument * doc,QDomElement * node);
};

void        QSection::loadFromStream(QDomDocument * doc,QDomElement * node)
{
    QRailItem::loadFromStream(doc,node); //загрузка части предка
    QDomElement sectionNode = node->firstChildElement("SimpleSectionData"); //находим часть этого класса
    if(!sectionNode.isNull()) //далее все грузится все что касается этого класса, так как размер, позицию и прочее мы узнали при загрузке базового класса
    {
        QDomElement anchorsNode = sectionNode.firstChildElement("Anchors");
        if(!anchorsNode.isNull())
        for(QDomNode anchorNode = anchorsNode.firstChildElement("Anchor");!anchorNode.isNull();anchorNode = anchorNode.nextSibling())
        {
            QDomElement anchorElement = anchorNode.toElement();
            if(!anchorElement.isNull())
            {
                bool    ok;
                QPointF currentAnchor;
                currentAnchor.setX(anchorElement.attribute("PosX").toFloat(&ok));
                currentAnchor.setY(anchorElement.attribute("PosY").toFloat(&ok));
                fpolygon.addPoint(currentAnchor);
            }
        }
    }
}

void        QSection::saveToStream(QDomDocument * doc,QDomElement * node)
{
    QRailItem::saveToStream(doc,node); //сохраняем часть базового класса

    QDomElement sectionNode = doc->createElement("SimpleSectionData"); //теперь все что связано с этим классом

    //получаем список опорных точек полигона секции
    QList<QPointF>* anchors_list = fpolygon.anchors();
    QPointF current_acnchor;

    QDomElement anchors = doc->createElement("Anchors");

    for(QList<QPointF>::iterator current_anchor_it=anchors_list->begin();current_anchor_it!=anchors_list->end();current_anchor_it++)
    {
        current_acnchor = *current_anchor_it;
        QDomElement anchor = doc->createElement("Anchor");
        anchor.setAttribute("PosX",current_acnchor.x());
        anchor.setAttribute("PosY",current_acnchor.y());
        anchors.appendChild(anchor);
    }

    sectionNode.appendChild(anchors);
    node->appendChild(sectionNode);
}

//находим секцию с эелементами поля
    QDomElement     fieldObjects = root.firstChildElement("FieldObjects");
    if(fieldObjects.isNull()) return false;

    scene()->setLastId(fieldObjects.attribute("LastId","0").toLong(&ok));

    for(QDomNode  fieldNode = fieldObjects.firstChildElement("FieldObject");!fieldNode.isNull();fieldNode = fieldNode.nextSibling())
    {
        QDomElement fieldObject = fieldNode.toElement();
        if(fieldObject.isNull()) continue;

        object_type = fieldObject.attribute("ObjectType");
//тут грузятся много разных объектов разных классов
//****
//находим наш объект
        if(object_type=="Section")
        {
            QSection * section = new QSection(false); //создаем объект
            section->loadFromStream(&doc,&fieldObject); //грузим ноду объекта
            section->recalculate(); //внутренние пересчеты
            fscene->addSection(section); //добавляем на сцену
            continue; //дальше нет смысла идти, ищем следующий объект ...
        }
//***
    }

//теперь сохраняем данные о графических объектах
    QDomElement     fieldObjects = doc.createElement("FieldObjects");
    fieldObjects.setAttribute("LastId",scene()->lastId());
    root.appendChild(fieldObjects);

    for(QList<QGraphicsItem*>::iterator items_it = fitems.begin();items_it!=fitems.end();items_it++) //проходимся по всей сцене
    {
        gi = *items_it;
        if((item = dynamic_cast<QRailItem*>(gi))==NULL) continue; //если не наследник от QRailItem проходим далее
        //пишем новую секцию <FieldObject>

        object_type = item->type();

        switch(object_type)
        {
        case    otRailItem:
            param = "RailItem";
            break;
//****
        case    otSection:
            param = "Section";
            break;
//****
        default:    //остальные игнорируем
            continue;
        }

        QDomElement fieldObject = doc.createElement("FieldObject"); //создаем ноду объекта сцены
        fieldObject.setAttribute("ObjectType",param); //пишем тип объекта

        switch(object_type)
        {
//***
            case    otSection:
            {
                if((section = dynamic_cast<QSection*>(item))!=NULL)
                section->saveToStream(&doc,&fieldObject);
            }
            break;

//****
            default:
                break;
            }
            //завершаем секцию <FiledObject>
            fieldObjects.appendChild(fieldObject);
        }

class QRailItem : public QObject, public QGraphicsItem
{
    Q_OBJECT
    Q_INTERFACES (QGraphicsItem)

protected:

    QFont           ffont;
    bool            fupdating;
    QString         fname;
    QRectF          fboundRect;
    TObjectType     fobjectType;
    quint32 id;
...
};

#include <QLCDNumber>
#include <QDateTime>
#include <QGraphicsWidget>
#include <time.h>

class SCB_DigitalClock : public QLCDNumber ,public QGraphicsWidget
{
    Q_OBJECT
    Q_INTERFACES(QGraphicsWidget)

    QDateTime   dt;
    time_t      oldTime;

public:
    explicit SCB_DigitalClock(QWidget *parent = 0);
    void     showTime(time_t * time_value);

signals:

public slots:

    void    updateTime(time_t ATime);

};

class QRailItem : public    QObject,    public QGraphicsItem
{
    Q_OBJECT
    Q_INTERFACES (QGraphicsItem)

protected:

    bool            fupdating;
    QString         fname;
    TObjectType     fobjectType;
...
};

class QRailItem : public    QLCDNumber,    public QGraphicsWidget
{
    Q_OBJECT
    Q_INTERFACES (QGraphicsWidget)
...
}

class QMMNClient : public QObject
{
    Q_OBJECT

    QTcpSocket    * fsocket;
    QTimer        * freqTimer;
    QMutex        * fmutex;

    quint16         fblockSize;
    quint16         fleftBytes;
    quint32         freconnTimeot;

public:

    explicit QMMNClient(QObject *parent = 0);
    ~QMMNClient();

    int      id;

    QString         remoteHost;
    quint16         remotePort;

    void            connectToServer();
    void            disconnectFromServer();
    void            moveToThread(QThread *thread);
    bool            safeGetData(mmn_frame_t * destFrame, size_t  frameSize);

signals:

    void            connected(int id);
    void            disconnected(int id);
    void            frameReceived(int id);

private slots:

    void            readyRead();
    void            onConnected();
    void            onDisconnected();
    void            doRequest();

public slots:

    void            sendRequest();

};

//реализация

QMMNClient::QMMNClient(QObject *parent) :
    QObject(parent)
{
    id = 0;
    fsocket = new QTcpSocket;
    remoteHost = "127.0.0.1";
    remotePort = 10000;
    freconnTimeot = 2;
    freqTimer = new QTimer;
    freqTimer->setInterval(250);
    fmutex = new QMutex;
//эти соыбтия обрабатываю внутри потока сетевого клиента
    connect(fsocket,SIGNAL(connected()),this,SLOT(onConnected()));
    connect(fsocket,SIGNAL(disconnected()),this,SLOT(onDisconnected()));
    connect(fsocket,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(onDisconnected()));
    connect(fsocket,SIGNAL(readyRead()),this,SLOT(readyRead())); //здесь читаю
    connect(freqTimer,SIGNAL(timeout()),this,SLOT(doRequest())); //переодический запрос на сервер
}

QMMNClient::~QMMNClient()
{
    freqTimer->stop();
    fsocket->abort();
    delete  fsocket;
    delete  freqTimer;
    delete  fmutex;
    if(frawBuffer) free(frawBuffer);
}

void     QMMNClient::readyRead()
{
    if(fblockSize==0)
    {
        if(fsocket->bytesAvailable()<sizeof(scb_msg_t)) return;
        fblockSize = fsocket->read(frawBuffer,sizeof(scb_msg_t));
        if(fframeBuffer.msg_head->size==0)
        {
            fblockSize = 0;
            return;
        }
        qDebug("block %d\n, header.size %d",fblockSize,fframeBuffer.msg_head->size);
    }

    fblockSize=fsocket->bytesAvailable();
    fleftBytes = fframeBuffer.msg_head->size-sizeof(scb_msg_t);

    if(fblockSize>=(fleftBytes))
    {
        fmutex->lock();
        fblockSize = fsocket->read(&frawBuffer[sizeof(scb_msg_t)],fleftBytes);
        fmutex->unlock();
        qDebug("fblockSize %d\n",fblockSize);
        fblockSize = 0;
        emit frameReceived(id); //надо это событие обработать в потоке GUI
    }
}

bool     QMMNClient::safeGetData(mmn_frame_t * destFrame, size_t  frameSize)
{
    if(destFrame && (frameSize==fframeSize))
    {
        fmutex->lock();
        qMemCopy(destFrame,&fframeBuffer,fframeSize);
        fmutex->unlock();
        return true;
    }
    return false;
}

void     QMMNClient::onConnected()
{
    fblockSize = 0;
//    qDebug("connected channel %d\n",id);
    emit    connected(id);
    freqTimer->start(250);
}

void     QMMNClient::onDisconnected()
{
//    qDebug("disconnected channel %d\n",id);
    freqTimer->stop();
    fsocket->close();
    emit    disconnected(id);
    sleep(freconnTimeot);
    fsocket->connectToHost(remoteHost,remotePort);
}

void     QMMNClient::doRequest()
{
    sendRequest();
}

void     QMMNClient::connectToServer()
{
    fsocket->connectToHost(remoteHost,remotePort);
}

void     QMMNClient::disconnectFromServer()
{
    fsocket->close();
}

void      QMMNClient::sendRequest()
{
    fsocket->write((const char*)&frequest,frequestSize); //отправляем некую структурку на сервер, на которую он должен ответить
}

void      QMMNClient::moveToThread(QThread *thread)
{
    QObject::moveToThread(thread); //двигаем себя в нужный поток
    if(fsocket) fsocket->moveToThread(thread); //сокет
    if(freqTimer) freqTimer->moveToThread(thread); //и таймер
}

class QMMNClientThread : public QThread
{
    Q_OBJECT

    void            run();

public:
    explicit QMMNClientThread(QObject *parent = 0);
    ~QMMNClientThread();

    QMMNClient   *   mmnClient;

signals:

public slots:

};

// реализация

QMMNClientThread::QMMNClientThread(QObject *parent) :
    QThread(parent)
{
    mmnClient = new QMMNClient;
    mmnClient->moveToThread(this);
}

QMMNClientThread::~QMMNClientThread()
{
    quit();
    wait();
}

void    QMMNClientThread::run()
{
    mmnClient->connectToServer();
    exec();
}

        mmnClientThread = new QMMNClientThread(this);
        mmnClientThread->mmnClient->remoteHost = ecHost[i];
        mmnClientThread->mmnClient->remotePort = ecPort[i];
        connect(mmnClientThread->mmnClient,SIGNAL(frameReceived(int)),this,SLOT(data_receive(int)),Qt::BlockingQueuedConnection);//здесь будет обращение к GUI
        connect(mmnClientThread->mmnClient,SIGNAL(connected(int)),this,SLOT(chan_connected(int)));
        connect(mmnClientThread->mmnClient,SIGNAL(disconnected(int)),this,SLOT(chan_disconnected(int)));
        mmnClientThread->start();