ref: draft

.gitignore

@@ -59,3 +59,4 @@ compile_commands.json
 debug/
 release/
 saves/
+build/

Core/UpdateController.cpp

@@ -1,17 +1,19 @@
 #include "UpdateController.h"
 
-UpdateController::UpdateController(DataParser *parser,SendSystem *sendSystem, QObject *parent) :
+
+#include <QThread>
+
+UpdateController::UpdateController(DataParserOutput *dataParserOut, SendSystem *sendSystem, QObject *parent) :
     QObject(parent)
 {
-    this->dataParser = parser;
     this->sendSystem = sendSystem;
+    this->dataParserOut = dataParserOut;
     applicationFolderPath = QDir::currentPath() + applicationFolderName;
 }
 
-void UpdateController::initialize(MainWindow *mainWindow,VersionContainer *versionContainer)
+void UpdateController::initialize(VersionContainer *versionContainer)
 {
     this->versionContainer = versionContainer;
-    connect(this,&UpdateController::sigUpdateComplete,mainWindow,&MainWindow::showCompleteDialogBox);
 }
 
 void UpdateController::calculateCommonHash()
@@ -20,7 +22,7 @@ void UpdateController::calculateCommonHash()
     appDataList = calculateHash(applicationFolderPath,"StreamingAssets");
     calculateStreamingHash();
     appDataList.append(streamingDataList);
-    dataParser->createFileDataList(appDataList,fullStaticDataFolderName + hashFilename);
+    dataParserOut->createFileDataList(appDataList,fullStaticDataFolderName + hashFilename);
     qDebug() << "UpdateController threadID " << QThread::currentThreadId();
 }
 
@@ -29,7 +31,7 @@ void UpdateController::calculateStreamingHash()
     streamingDataList.clear();
     streamingDataList = calculateHash(QDir::currentPath() + streamingAssetsPath,"");
     std::sort(streamingDataList.begin(),streamingDataList.end());
-    dataParser->createFileDataList(streamingDataList,streamingHashFilename);
+    dataParserOut->createFileDataList(streamingDataList,streamingHashFilename);
 }
 
 QList<FileData> UpdateController::calculateHash(QString path,QString ignoreName)
@@ -107,12 +109,6 @@ QList<FileData> UpdateController::calculateHash(QString path,QString ignoreName)
     return *hashes;
 }
 
-void UpdateController::checkCanUpdate()
-{
-    QByteArray checkUpdate = dataParser->xmlAnswer_notify("CANCHANGE");
-    sendSystem->sendXMLAnswer(checkUpdate);
-}
-
 void UpdateController::updateFilesOnServer(QList<FileData> *fileSendList){
 
     QListIterator<FileData> serverIterator(*fileSendList);

Core/UpdateController.h

@@ -1,6 +1,8 @@
 #ifndef UPDATECONTROLLER_H
 #define UPDATECONTROLLER_H
 
+#include "Core/sendsystem.h"
+#include "Core/versioncontainer.h"
 #include <QXmlStreamWriter>
 #include <QXmlStreamReader>
 #include <QXmlStreamAttribute>
@@ -15,14 +17,8 @@
 #include <QDialogButtonBox>
 
 #include <Data\FileData.h>
-#include <Core\dataparser.h>
-#include <Core\tcpclient.h>
 #include <Data\streamingversiondata.h>
-
+#include <Core\dataparseroutput.h>
-class SendSystem;
-class MainWindow;
-class DataParser;
-class VersionContainer;
 
 class UpdateController : public QObject
 {
@@ -30,11 +26,10 @@ class UpdateController : public QObject
     Q_OBJECT
 
 public:
-    explicit UpdateController(DataParser *parser,
+    explicit UpdateController(DataParserOutput *dataParser, SendSystem *sendSystem,
-                              SendSystem *sendSystem,
                               QObject *parent = 0);
 
-    void initialize(MainWindow *mainWindow,VersionContainer *versionContainer);
+    void initialize(VersionContainer *versionContainer);
     void calculateCommonHash();
     void calculateStreamingHash();
     ~UpdateController();
@@ -45,8 +40,8 @@ public:
 signals:
     void sigUpdateComplete(bool flag);
 private:
-    DataParser *dataParser;
     SendSystem *sendSystem;
+    DataParserOutput * dataParserOut;
     QString applicationFolderPath;
     VersionContainer *versionContainer;
     QList<FileData> appDataList;

Core/dataparser.cpp

@@ -8,211 +8,11 @@ DataParser::DataParser(QObject *parent) :
     }
 }
 
-void DataParser::initialize(RecognizeSystem *recognizeSystem,
+void DataParser::initialize()
-                            NotifyController *notifyController,
-                            UpdateController *updateController,
-                            HashComparer *hashComparer)
 {
-    this->recognizeSystem = recognizeSystem;
-    this->notifyController = notifyController;
-    this->hashComparer = hashComparer;
-
-    connect(this,&DataParser::sigNotify,notifyController,&NotifyController::showWarning,Qt::AutoConnection);
-    connect(this,&DataParser::sigUpdateFilesOnServer,updateController,&UpdateController::updateFilesOnServer,Qt::AutoConnection);
-}
-
-void DataParser::createFileDataList(QList<FileData> fileDataList,QString filename)
-{
-
-    QFile file(filename);
-    file.open(QIODevice::WriteOnly);
-    QXmlStreamWriter xmlWriter(&file);
-
-    xmlWriter.setAutoFormatting(true);
-    xmlWriter.writeStartDocument();
-    xmlWriter.writeStartElement("FileDataList");
-
-    foreach (FileData data,fileDataList)
-    {
-        xmlWriter.writeStartElement("FileData");
-
-        xmlWriter.writeAttribute("Path",data.path);
-        xmlWriter.writeAttribute("Hash",data.hash);
-
-        xmlWriter.writeEndElement();
-    }
-
-    xmlWriter.writeEndElement();
-    xmlWriter.writeEndDocument();
-
-    file.close();
-}
-
-void DataParser::createAuthMessage(ClientAutorization *auth)
-{
-    authPassCache = auth; //кэширование даных авторизации, для сохранения при успешном заходе
-
-    QFile file(tempName);
-    file.open(QIODevice::WriteOnly);
-    QXmlStreamWriter xmlWriter(&file);
-
-    xmlWriter.setAutoFormatting(true);
-    xmlWriter.writeStartDocument();
-    xmlWriter.writeStartElement("ClientAutorization");
-
-    xmlWriter.writeAttribute("Login",auth->Login);
-    xmlWriter.writeAttribute("Password",auth->Password);
-
-    xmlWriter.writeEndElement();
-    xmlWriter.writeEndElement();
-    xmlWriter.writeEndDocument();
-
-    file.close();
-}
-
-void DataParser::createServerSettings(ServerSettings* serverSettings)
-{
-    QFile file(settingsName);
-
-    file.open(QIODevice::WriteOnly);
-
-    QXmlStreamWriter xmlWriter(&file);
-
-    xmlWriter.setAutoFormatting(true);
-    xmlWriter.writeStartDocument();
-
-    xmlWriter.writeStartElement("ServerSettingsContainer");
-    xmlWriter.writeStartElement("ServerSettings");
-
-    xmlWriter.writeAttribute("Address",serverSettings->Address);
-    xmlWriter.writeAttribute("Port",serverSettings->Port);
-    xmlWriter.writeAttribute("Language","RUS");
-    xmlWriter.writeAttribute("AutoStart",QString::number(false));
-    xmlWriter.writeAttribute("DestPortMath","18003");
-    xmlWriter.writeAttribute("LocalPortMath","18004");    
-    xmlWriter.writeAttribute("UseMathModel",QString::number(serverSettings->mathModelUse));
-
-    xmlWriter.writeEndElement();
-
-    if(serverSettings->LocalVersionName == "")
-    {
-        xmlWriter.writeStartElement("VersionData");
-        xmlWriter.writeAttribute("Version","NONE");
-        xmlWriter.writeAttribute("isChangable","0");
-        xmlWriter.writeEndElement();
-    }
-    else
-    {
-        xmlWriter.writeStartElement("VersionData");
-        xmlWriter.writeAttribute("Version",serverSettings->versionData.getViewName());
-        xmlWriter.writeAttribute("isChangable",QString::number(serverSettings->versionData.getIsChangeable()));
-    }
-
-    xmlWriter.writeEndElement();
-
-    xmlWriter.writeEndDocument();
-
-    file.close();
 
 }
 
-void DataParser::changeVersion(StreamingVersionData *versionData)
-{
-    QFile file(settingsName);
-
-    file.open(QIODevice::ReadWrite);
-    QByteArray xmlData(file.readAll());
-
-    QDomDocument doc;
-    doc.setContent(xmlData);
-    QDomElement containerElement = doc.firstChildElement("ServerSettingsContainer");
-    QDomElement verDataElement = containerElement.firstChildElement("VersionData");
-    verDataElement.setAttribute("Version",versionData->getViewName());
-    verDataElement.setAttribute("Created",versionData->getCreateData().toString());
-    verDataElement.setAttribute("isChangable",versionData->getIsChangeable());
-
-    file.resize(0);
-    QTextStream out(&file);
-    doc.save(out,4);
-
-    file.close();
-
-}
-
-void DataParser::createAuthData(ServerAuthorization *serverAuth)
-{
-    QFile file(authTempName);
-    file.open(QIODevice::WriteOnly);
-
-    QXmlStreamWriter xmlWriter(&file);
-
-    xmlWriter.setAutoFormatting(true);
-    xmlWriter.writeStartDocument();
-    xmlWriter.writeStartElement("AuthData");
-    xmlWriter.writeAttribute("Login",authPassCache->Login);
-    xmlWriter.writeAttribute("Password",authPassCache->Password);
-    xmlWriter.writeAttribute("InstructorName",serverAuth->InstructorName);
-    xmlWriter.writeAttribute("ClientName",serverAuth->ClientName);
-    xmlWriter.writeAttribute("AccessType",serverAuth->AccessType);
-
-    xmlWriter.writeEndElement();
-    file.close();
-
-}
-
-void DataParser::createAuthDataOffline(QString username, QString pass)
-{
-    QFile file(authTempName);
-    file.open(QIODevice::WriteOnly);
-
-    QXmlStreamWriter xmlWriter(&file);
-
-    xmlWriter.setAutoFormatting(true);
-    xmlWriter.writeStartDocument();
-    xmlWriter.writeStartElement("AuthData");
-    xmlWriter.writeAttribute("Login",username);
-    xmlWriter.writeAttribute("Password",pass);
-    xmlWriter.writeAttribute("InstructorName","empty");
-    xmlWriter.writeAttribute("ClientName","Offline");
-    xmlWriter.writeAttribute("AccessType","Offline");
-
-    xmlWriter.writeEndElement();
-    file.close();
-}
-
-QByteArray DataParser::xmlAnswer_notify(QString code)
-{
-
-    QList<SXmlAnswerTag> listTag;
-
-    SAttribute attribute1 = {"Code", code};
-    QList<SAttribute> listAttr = {attribute1};
-    SXmlAnswerTag tag = {"ClientNotify", listAttr};
-
-    listTag.append(tag);
-
-    return xmlAnswer(listTag);
-}
-
-void DataParser::addRunData(QList<int> displays)
-{
-    QFile file(displayTemp);
-    file.open(QIODevice::WriteOnly);
-    QString data;
-
-    for(int i = 0; i < displays.count(); i++)
-    {
-        data.append(QString::number(displays[i]) + ";");
-    }
-
-    QXmlStreamWriter xmlWriter(&file);
-    xmlWriter.setAutoFormatting(true);
-    xmlWriter.writeStartElement("DisplayInfo");
-    xmlWriter.writeAttribute("DisplaysID",data);
-    xmlWriter.writeEndElement();
-    file.close();
-
-}
 
 ServerSettings *DataParser::getClientSettings()
 {
@@ -294,127 +94,6 @@ ServerSettings *DataParser::getClientSettings()
     return settings;
 }
 
-void DataParser::saveClientSettrings(QString language, bool isAutoStart)
-{
-    QFile file(settingsName);
-    file.open(QIODevice::ReadOnly | QIODevice::Text);
-
-    QString settings = file.readAll();
-
-    file.close();
-    file.remove();
-
-    file.open(QIODevice::WriteOnly | QIODevice::Text);
-
-    auto languagePos = settings.indexOf(XMLLanguageProperty) + XMLLanguageProperty.length();
-    settings = settings.replace(languagePos,language.size(),language);
-
-    auto autoStartPos = settings.indexOf(XMLAutoStartProperty) + XMLAutoStartProperty.length();
-    settings = settings.replace(autoStartPos,1,QString::number(isAutoStart));
-
-    file.write(settings.toUtf8());
-    file.close();
-}
-
-QList<FileData>* DataParser::xmlFileDataParse(QByteArray array, QString filter = "")
-{
-    QXmlStreamReader xmlReader(array);
-    QList<FileData> *datas = new QList<FileData>;
-    xmlReader.readNext();   // Переходим к первому элементу в файле
-
-    //Крутимся в цикле до тех пор, пока не достигнем конца документа
-    while(!xmlReader.atEnd())
-    {
-        //Проверяем, является ли элемент началом тега
-        if(xmlReader.isStartElement())
-        {
-            if(xmlReader.name() == "FileData")
-            {
-                FileData data;
-
-                foreach(const QXmlStreamAttribute &attr,xmlReader.attributes())
-                {
-                    QString name = attr.name().toString();
-                    QString value = attr.value().toString();
-
-                    if(name == "Path")
-                        data.path = value;
-                    else if(name == "Hash")
-                        data.hash = value;
-                }
-
-                if(data.path.contains(filter))
-
-                datas->append(data);
-            }
-        }
-
-        xmlReader.readNext();
-    }
-
-    return datas;
-}
-
-QByteArray DataParser::xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1, QString elemUp2)
-{
-    /* Открываем файл для Записи*/
-    QFile file(tempName);
-    file.open(QIODevice::WriteOnly);
-
-    /* Создаем объект, с помощью которого осуществляется запись в файл */
-    QXmlStreamWriter xmlWriter(&file);
-
-    xmlWriter.setAutoFormatting(true);  // Устанавливаем автоформатирование текста
-
-    xmlWriter.writeStartDocument();     // Запускаем запись в документ
-
-    if(elemUp1 != "")
-        xmlWriter.writeStartElement(elemUp1);   // Записываем тег
-
-    if(elemUp2 != "")
-        xmlWriter.writeStartElement(elemUp2);   // Записываем тег
-
-    //Записываем все элементы
-    foreach(SXmlAnswerTag tag, listTag)
-    {
-        xmlWriter.writeStartElement(tag.elementName);   // Записываем тег
-
-        // Записываем атрибуты
-        foreach(SAttribute attr, tag.attr)
-            xmlWriter.writeAttribute(attr.name, attr.value);
-
-        xmlWriter.writeEndElement();        // Закрываем тег
-    }
-
-    if(elemUp1 != "")
-        xmlWriter.writeEndElement();        // Закрываем тег
-
-    if(elemUp1 != "")
-        xmlWriter.writeEndElement();        // Закрываем тег
-
-    /* Завершаем запись в документ*/
-    xmlWriter.writeEndDocument();
-
-    file.close();   // Закрываем файл
-
-    QByteArray array;
-
-    /* Открываем файл для Чтения*/
-    QFile fileR(tempName);
-    if (!fileR.open(QFile::ReadOnly | QFile::Text))
-    {
-        QString str = "Не удалось открыть файл";
-        qDebug() << "xmlAnswer: " << str;
-    }
-    else
-    {
-        array = fileR.readAll();
-        fileR.close();   // Закрываем файл
-    }
-
-    return array;
-}
-
 void DataParser::xmlParser(QByteArray array)
 {
     QXmlStreamReader xmlReader(array);
@@ -439,17 +118,17 @@ void DataParser::xmlParser(QByteArray array)
                 {
                     if (value == "END")
                     {
-                        emit recognizeSystem->sigSocketDisabled();
+                        postProcessorSystem->socketDisable();
                     }
 
                     if (value == "BLOCKED")
                     {
-                        emit recognizeSystem->sigServerBlocked();
+                        postProcessorSystem->serverBlocked();
                     }
 
                     if (value == "HASHSENDCOMPLETE")
                     {
-                        emit recognizeSystem->sigStartCompare();
+                        postProcessorSystem->startCompare();
                     }
 
                     if (value == "BASEDELETETRY")
@@ -470,12 +149,14 @@ void DataParser::xmlParser(QByteArray array)
                     if (value == "UNCHANGEABLE")
                     {
                         emit sigNotify(tr("Нельзя выгружать в базовую версию"));
-                        emit recognizeSystem->sigShowUpdateList();
+                        postProcessorSystem->showUpdateList();
+                        //emit recognizeSystem->sigShowUpdateList();
                     }
 
                     if (value == "CHANGEABLE")
                     {
-                        emit sigUpdateFilesOnServer(hashComparer->getFilesForUpdate());
+                        postProcessorSystem->compareFiles();
+                        //emit sigUpdateFilesOnServer(hashComparer->getFilesForUpdate());
                     }
                 }
             }
@@ -504,11 +185,13 @@ void DataParser::xmlParser(QByteArray array)
 
                 if (name == "AccessType"){
                     serverAuth->AccessType = value;
-                    recognizeSystem->checkAccessType(value);
+                    postProcessorSystem->checkAccessType(value);
+                    //recognizeSystem->checkAccessType(value);
                 }
             }
 
-            emit recognizeSystem->sigSaveLoginData(serverAuth);
+            postProcessorSystem->saveLoginData(serverAuth);
+            //emit recognizeSystem->sigSaveLoginData(serverAuth);
         }
 
         if(xmlReader.name() == "VersionData")
@@ -535,7 +218,8 @@ void DataParser::xmlParser(QByteArray array)
                 }
 
             }
-            recognizeSystem->setServerVersion(serverVersion);
+            postProcessorSystem->setServerVersion(serverVersion);
+            //recognizeSystem->setServerVersion(serverVersion);
         }
 
         if(xmlReader.name() == "VersionList")
@@ -572,7 +256,7 @@ void DataParser::xmlParser(QByteArray array)
 
                 xmlReader.readNext();
             }
-            recognizeSystem->showServerDataList(serverStreamingVersionDataList);
+            postProcessorSystem->showServerDataList(serverStreamingVersionDataList);
         }
 
         xmlReader.readNext();

Core/dataparser.h

@@ -1,7 +1,6 @@
 #ifndef DATAPARSER_H
 #define DATAPARSER_H
 
-
 #include <QDir>
 #include <QFile>
 #include <QObject>
@@ -10,13 +9,10 @@
 #include <Data/FileData.h>
 #include <Data/Datas.h>
 #include <Data/FileData.h>
-#include <Core/recognizesystem.h>
 #include <Core/tools.h>
+#include "Core/postprocessorsystem.h"
 
-class RecognizeSystem;
 class NotifyController;
-class UpdateController;
-class HashComparer;
 
 class DataParser : public QObject
 {
@@ -25,41 +21,19 @@ class DataParser : public QObject
 
 public:
     explicit DataParser(QObject *parent = 0);
-    void initialize(RecognizeSystem *recognizeSystem,
+    void initialize();
-                    NotifyController *notifyController,
-                    UpdateController *updateController,
-                    HashComparer *hashComparer);
 
     ~DataParser();
     ServerSettings* getClientSettings();
-    void createServerSettings(ServerSettings* serverSettings);
-    void saveClientSettrings(QString language,bool isAutoStart);
-    void createFileDataList(QList<FileData> fileDataList,QString filename);
-    void createAuthMessage(ClientAutorization *auth);
-    void createAuthData(ServerAuthorization *serverAuth);
-    void createAuthDataOffline(QString username,QString pass);
-    void addRunData(QList<int> displays);    
-    QByteArray xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1 = "", QString elemUp2 = "");
-    QList<FileData>* xmlFileDataParse(QByteArray array,QString filter);
-
     void xmlParser(QByteArray array);
-    void changeVersion(StreamingVersionData *versionData);
 
 signals:
     void sigNotify(QString notify);
     void sigUpdateFilesOnServer(QList<FileData> *fileSendList);
-public slots:
-    QByteArray xmlAnswer_notify(QString code);
-
 
 private:
-    const QString XMLLanguageProperty = "Language=\"";
-    const QString XMLAutoStartProperty = "AutoStart=\"";
     ClientAutorization *authPassCache;
-    RecognizeSystem *recognizeSystem;
+    PostProcessorSystem *postProcessorSystem;
-    NotifyController *notifyController;
-    HashComparer *hashComparer;
-
 };
 
 #endif // DATAPARSER_H

Core/dataparserouput.cpp

@@ -0,0 +1,3 @@
+#include "dataparserouput.h"
+
+dataParserOuput::dataParserOuput() {}

Core/dataparserouput.h

@@ -0,0 +1,13 @@
+#ifndef DATAPARSEROUPUT_H
+#define DATAPARSEROUPUT_H
+
+#include <QObject>
+
+class dataParserOuput
+{
+    Q_OBJECT
+public:
+    dataParserOuput();
+};
+
+#endif // DATAPARSEROUPUT_H

Core/dataparseroutput.cpp

@@ -0,0 +1,317 @@
+#include "dataparseroutput.h"
+
+DataParserOutput::DataParserOutput() {}
+
+QByteArray DataParserOutput::xmlAnswer_notify(QString code)
+{
+
+    QList<SXmlAnswerTag> listTag;
+
+    SAttribute attribute1 = {"Code", code};
+    QList<SAttribute> listAttr = {attribute1};
+    SXmlAnswerTag tag = {"ClientNotify", listAttr};
+
+    listTag.append(tag);
+
+    return xmlAnswer(listTag);
+}
+
+QByteArray DataParserOutput::xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1, QString elemUp2)
+{
+    /* Открываем файл для Записи*/
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+
+    /* Создаем объект, с помощью которого осуществляется запись в файл */
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);  // Устанавливаем автоформатирование текста
+
+    xmlWriter.writeStartDocument();     // Запускаем запись в документ
+
+    if(elemUp1 != "")
+        xmlWriter.writeStartElement(elemUp1);   // Записываем тег
+
+    if(elemUp2 != "")
+        xmlWriter.writeStartElement(elemUp2);   // Записываем тег
+
+    //Записываем все элементы
+    foreach(SXmlAnswerTag tag, listTag)
+    {
+        xmlWriter.writeStartElement(tag.elementName);   // Записываем тег
+
+        // Записываем атрибуты
+        foreach(SAttribute attr, tag.attr)
+            xmlWriter.writeAttribute(attr.name, attr.value);
+
+        xmlWriter.writeEndElement();        // Закрываем тег
+    }
+
+    if(elemUp1 != "")
+        xmlWriter.writeEndElement();        // Закрываем тег
+
+    if(elemUp1 != "")
+        xmlWriter.writeEndElement();        // Закрываем тег
+
+    /* Завершаем запись в документ*/
+    xmlWriter.writeEndDocument();
+
+    file.close();   // Закрываем файл
+
+    QByteArray array;
+
+    /* Открываем файл для Чтения*/
+    QFile fileR(tempName);
+    if (!fileR.open(QFile::ReadOnly | QFile::Text))
+    {
+        QString str = "Не удалось открыть файл";
+        qDebug() << "xmlAnswer: " << str;
+    }
+    else
+    {
+        array = fileR.readAll();
+        fileR.close();   // Закрываем файл
+    }
+
+    return array;
+}
+
+
+void DataParserOutput::createFileDataList(QList<FileData> fileDataList,QString filename)
+{
+    QFile file(filename);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("FileDataList");
+
+    foreach (FileData data,fileDataList)
+    {
+        xmlWriter.writeStartElement("FileData");
+
+        xmlWriter.writeAttribute("Path",data.path);
+        xmlWriter.writeAttribute("Hash",data.hash);
+
+        xmlWriter.writeEndElement();
+    }
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+void DataParserOutput::createAuthMessage(ClientAutorization *auth)
+{
+    authPassCache = auth; //кэширование даных авторизации, для сохранения при успешном заходе
+
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("ClientAutorization");
+
+    xmlWriter.writeAttribute("Login",auth->Login);
+    xmlWriter.writeAttribute("Password",auth->Password);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+void DataParserOutput::createServerSettings(ServerSettings* serverSettings)
+{
+    QFile file(settingsName);
+
+    file.open(QIODevice::WriteOnly);
+
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+
+    xmlWriter.writeStartElement("ServerSettingsContainer");
+    xmlWriter.writeStartElement("ServerSettings");
+
+    xmlWriter.writeAttribute("Address",serverSettings->Address);
+    xmlWriter.writeAttribute("Port",serverSettings->Port);
+    xmlWriter.writeAttribute("Language","RUS");
+    xmlWriter.writeAttribute("AutoStart",QString::number(false));
+    xmlWriter.writeAttribute("DestPortMath","18003");
+    xmlWriter.writeAttribute("LocalPortMath","18004");
+    xmlWriter.writeAttribute("UseMathModel",QString::number(serverSettings->mathModelUse));
+
+    xmlWriter.writeEndElement();
+
+    if(serverSettings->LocalVersionName == "")
+    {
+        xmlWriter.writeStartElement("VersionData");
+        xmlWriter.writeAttribute("Version","NONE");
+        xmlWriter.writeAttribute("isChangable","0");
+        xmlWriter.writeEndElement();
+    }
+    else
+    {
+        xmlWriter.writeStartElement("VersionData");
+        xmlWriter.writeAttribute("Version",serverSettings->versionData.getViewName());
+        xmlWriter.writeAttribute("isChangable",QString::number(serverSettings->versionData.getIsChangeable()));
+    }
+
+    xmlWriter.writeEndElement();
+
+    xmlWriter.writeEndDocument();
+
+    file.close();
+
+}
+
+void DataParserOutput::changeVersion(StreamingVersionData *versionData)
+{
+    QFile file(settingsName);
+
+    file.open(QIODevice::ReadWrite);
+    QByteArray xmlData(file.readAll());
+
+    QDomDocument doc;
+    doc.setContent(xmlData);
+    QDomElement containerElement = doc.firstChildElement("ServerSettingsContainer");
+    QDomElement verDataElement = containerElement.firstChildElement("VersionData");
+    verDataElement.setAttribute("Version",versionData->getViewName());
+    verDataElement.setAttribute("Created",versionData->getCreateData().toString());
+    verDataElement.setAttribute("isChangable",versionData->getIsChangeable());
+
+    file.resize(0);
+    QTextStream out(&file);
+    doc.save(out,4);
+
+    file.close();
+
+}
+
+void DataParserOutput::createAuthData(ServerAuthorization *serverAuth)
+{
+    QFile file(authTempName);
+    file.open(QIODevice::WriteOnly);
+
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("AuthData");
+    xmlWriter.writeAttribute("Login",authPassCache->Login);
+    xmlWriter.writeAttribute("Password",authPassCache->Password);
+    xmlWriter.writeAttribute("InstructorName",serverAuth->InstructorName);
+    xmlWriter.writeAttribute("ClientName",serverAuth->ClientName);
+    xmlWriter.writeAttribute("AccessType",serverAuth->AccessType);
+
+    xmlWriter.writeEndElement();
+    file.close();
+
+}
+
+void DataParserOutput::createAuthDataOffline(QString username, QString pass)
+{
+    QFile file(authTempName);
+    file.open(QIODevice::WriteOnly);
+
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("AuthData");
+    xmlWriter.writeAttribute("Login",username);
+    xmlWriter.writeAttribute("Password",pass);
+    xmlWriter.writeAttribute("InstructorName","empty");
+    xmlWriter.writeAttribute("ClientName","Offline");
+    xmlWriter.writeAttribute("AccessType","Offline");
+
+    xmlWriter.writeEndElement();
+    file.close();
+}
+
+void DataParserOutput::addRunData(QList<int> displays)
+{
+    QFile file(displayTemp);
+    file.open(QIODevice::WriteOnly);
+    QString data;
+
+    for(int i = 0; i < displays.count(); i++)
+    {
+        data.append(QString::number(displays[i]) + ";");
+    }
+
+    QXmlStreamWriter xmlWriter(&file);
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartElement("DisplayInfo");
+    xmlWriter.writeAttribute("DisplaysID",data);
+    xmlWriter.writeEndElement();
+    file.close();
+
+}
+
+void DataParserOutput::saveClientSettrings(QString language, bool isAutoStart)
+{
+    QFile file(settingsName);
+    file.open(QIODevice::ReadOnly | QIODevice::Text);
+
+    QString settings = file.readAll();
+
+    file.close();
+    file.remove();
+
+    file.open(QIODevice::WriteOnly | QIODevice::Text);
+
+    auto languagePos = settings.indexOf(XMLLanguageProperty) + XMLLanguageProperty.length();
+    settings = settings.replace(languagePos,language.size(),language);
+
+    auto autoStartPos = settings.indexOf(XMLAutoStartProperty) + XMLAutoStartProperty.length();
+    settings = settings.replace(autoStartPos,1,QString::number(isAutoStart));
+
+    file.write(settings.toUtf8());
+    file.close();
+}
+
+QList<FileData>* DataParserOutput::xmlFileDataParse(QByteArray array, QString filter = "")
+{
+    QXmlStreamReader xmlReader(array);
+    QList<FileData> *datas = new QList<FileData>;
+    xmlReader.readNext();   // Переходим к первому элементу в файле
+
+    //Крутимся в цикле до тех пор, пока не достигнем конца документа
+    while(!xmlReader.atEnd())
+    {
+        //Проверяем, является ли элемент началом тега
+        if(xmlReader.isStartElement())
+        {
+            if(xmlReader.name() == "FileData")
+            {
+                FileData data;
+
+                foreach(const QXmlStreamAttribute &attr,xmlReader.attributes())
+                {
+                    QString name = attr.name().toString();
+                    QString value = attr.value().toString();
+
+                    if(name == "Path")
+                        data.path = value;
+                    else if(name == "Hash")
+                        data.hash = value;
+                }
+
+                if(data.path.contains(filter))
+
+                datas->append(data);
+            }
+        }
+
+        xmlReader.readNext();
+    }
+
+    return datas;
+}

Core/dataparseroutput.h

@@ -0,0 +1,35 @@
+#ifndef DATAPARSEROUTPUT_H
+#define DATAPARSEROUTPUT_H
+
+#include <QObject>
+#include <Data/FileData.h>
+#include <Data/Datas.h>
+#include <Core/tools.h>
+#include <QFile>
+#include <QXmlStreamWriter>
+#include <QDomDocument>
+
+
+class DataParserOutput : public QObject
+{
+    Q_OBJECT
+public:
+    DataParserOutput();
+    void createFileDataList(QList<FileData> fileDataList, QString filename);
+    void createAuthMessage(ClientAutorization *auth);
+    void createServerSettings(ServerSettings *serverSettings);
+    void changeVersion(StreamingVersionData *versionData);
+    void createAuthData(ServerAuthorization *serverAuth);
+    void createAuthDataOffline(QString username, QString pass);
+    void addRunData(QList<int> displays);
+    void saveClientSettrings(QString language, bool isAutoStart);
+    QList<FileData> *xmlFileDataParse(QByteArray array, QString filter);
+    QByteArray xmlAnswer_notify(QString code);
+    QByteArray xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1 ="", QString elemUp2 ="");
+private:
+    const QString XMLLanguageProperty = "Language=\"";
+    const QString XMLAutoStartProperty = "AutoStart=\"";
+    ClientAutorization *authPassCache;
+};
+
+#endif // DATAPARSEROUTPUT_H

Core/hashcomparer.cpp

@@ -1,38 +1,25 @@
 #include "hashcomparer.h"
 
-HashComparer::HashComparer(DataParser *dataParser,QObject *)
+HashComparer::HashComparer(QObject *)
 {
-    this->dataParser = dataParser;
+
 }
 
-void HashComparer::initialize(MainWindow* mainWindow,VersionContainer *versionContainer)
+void HashComparer::initialize(VersionContainer *versionContainer)
 {
-    connect(this,&HashComparer::sigCallCheck,mainWindow,&MainWindow::checkUpdate);
+
-    connect(this,&HashComparer::sigHaveDelta,mainWindow,&MainWindow::showUpdateInfo);
     this->versionContainer = versionContainer;
 }
 
-void HashComparer::CompareDeltas()
+void HashComparer::CompareDeltas(QList<FileData> *serverStreamingHash, QList<FileData> localStreamingHash)
 {
-    QList<FileData> *serverStreamingHash = new QList<FileData>;
+    // QList<FileData> *serverStreamingHash = new QList<FileData>;
-    QList<FileData> *localStreamingHash = new QList<FileData>;
+    // QList<FileData> *localStreamingHash = new QList<FileData>;
     QList<FileData> *files = new QList<FileData>;
 
-    QFile file(serverHash);
+    QMutableListIterator<FileData> iterator(localStreamingHash);
-    file.open(QIODevice::ReadOnly | QIODevice::Text);
 
-    serverStreamingHash = dataParser->xmlFileDataParse(file.readAll(),"StreamingAssets");
+    for (auto &item:localStreamingHash)
-    file.close();
-
-    QFile file2(streamingHashFilename);
-    file2.open(QIODevice::ReadOnly | QIODevice::Text);
-
-    localStreamingHash = dataParser->xmlFileDataParse(file2.readAll(),"StreamingAssets");
-    file2.close();
-
-    QMutableListIterator<FileData> iterator(*localStreamingHash);
-
-    for (auto &item:*localStreamingHash)
     {
         if(!serverStreamingHash->contains(item))
         {

Core/hashcomparer.h

@@ -5,20 +5,19 @@
 #include <QObject>
 #include <QFile>
 #include <Data/FileData.h>
-#include <Core/dataparser.h>
 #include <Core/tools.h>
 #include <Widgets/updatenotifywidget.h>
-#include <Widgets/updatenotifywidget.h>
 
 class UpdateNotifyWidget;
 class VersionContainer;
+
 class HashComparer :public QObject
 {
     Q_OBJECT
 public:
-    explicit HashComparer(DataParser *dataParser,QObject *parent = nullptr);
+    explicit HashComparer(QObject *parent = nullptr);
-    void initialize(MainWindow* mainWindow,VersionContainer *versionContainer);
+    void initialize(VersionContainer *versionContainer);
-    void CompareDeltas();
+    void CompareDeltas(QList<FileData> *serverStreamingHash, QList<FileData> localStreamingHash);
     ~HashComparer();
 
     void showDeltas();
@@ -31,7 +30,6 @@ signals:
 private:
     UpdateNotifyWidget* updateWidget;
     QList<FileData> *filesForUpdate;
-    DataParser *dataParser;
     VersionContainer *versionContainer;
 };
 

Core/postprocessorsystem.cpp

@@ -0,0 +1,89 @@
+#include "postprocessorsystem.h"
+
+PostProcessorSystem::PostProcessorSystem() {}
+
+void PostProcessorSystem::initialize(DataParserOutput *dataParserOutput,
+                                     HashComparer *hashComparer,
+                                     VersionContainer* versionContainer,
+                                     UpdateController* updateController)
+{
+    this->hashComparer = hashComparer;
+    this->versionContainer = versionContainer;
+    this->updateController = updateController;
+    this->dataParserOutput = dataParserOutput;
+
+}
+
+void PostProcessorSystem::socketDisable()
+{
+    emit sigSocketDisabled();
+}
+
+void PostProcessorSystem::serverBlocked()
+{
+    emit sigServerBlocked();
+}
+
+void PostProcessorSystem::startCompare()
+{
+    QList<FileData> *serverStreamingHash = new QList<FileData>;
+    QList<FileData> *localStreamingHash = new QList<FileData>;
+
+    QFile file(serverHash);
+    file.open(QIODevice::ReadOnly | QIODevice::Text);
+
+    serverStreamingHash = dataParserOutput->xmlFileDataParse(file.readAll(),"StreamingAssets");
+    file.close();
+
+    QFile file2(streamingHashFilename);
+    file2.open(QIODevice::ReadOnly | QIODevice::Text);
+
+    localStreamingHash = dataParserOutput->xmlFileDataParse(file2.readAll(),"StreamingAssets");
+    file2.close();
+
+    emit sigStartCompare(serverStreamingHash,*localStreamingHash);
+}
+
+void PostProcessorSystem::showUpdateList()
+{
+    emit sigShowUpdateList();
+}
+
+void PostProcessorSystem::compareFiles()
+{
+    //emit sigCompareFiles()
+}
+
+void PostProcessorSystem::checkAccessType(QString type)
+{
+    if(type == "instructor")
+    {
+        emit sigCallUpdateList();
+    }
+}
+
+void PostProcessorSystem::saveLoginData(ServerAuthorization *auth)
+{
+
+}
+
+void PostProcessorSystem::setServerVersion(StreamingVersionData *serverVersion)
+{
+    versionContainer->setServerVersionData(serverVersion);
+}
+
+void PostProcessorSystem::showServerDataList(QList<StreamingVersionData *> *versionList)
+{
+
+}
+
+void PostProcessorSystem::calculateCommonHash()
+{
+    updateController->calculateCommonHash();
+}
+
+void UpdateController::checkCanUpdate()
+{
+    QByteArray checkUpdate = dataParserOut->xmlAnswer_notify("CANCHANGE");
+    sendSystem->sendXMLAnswer(checkUpdate);
+}

Core/postprocessorsystem.h

@@ -0,0 +1,46 @@
+#ifndef POSTPROCESSORSYSTEM_H
+#define POSTPROCESSORSYSTEM_H
+
+#include "Core/hashcomparer.h"
+#include "UpdateController.h"
+#include <QObject>
+#include <Data/Datas.h>
+
+class PostProcessorSystem : public QObject
+{
+    Q_OBJECT
+public:
+    PostProcessorSystem();
+    void initialize(DataParserOutput *dataParserOutput,
+                    HashComparer *hashComparer,
+                    VersionContainer* versionContainer,
+                    UpdateController* updateContorller);
+    void socketDisable();
+    void serverBlocked();
+    void startCompare();
+    void showUpdateList();
+    void compareFiles();
+    void checkAccessType(QString type);
+    void saveLoginData(ServerAuthorization *auth);
+    void setServerVersion(StreamingVersionData *serverVersion);
+    void showServerDataList(QList<StreamingVersionData*> *versionList);
+
+    void calculateCommonHash();
+signals:
+    void sigSocketDisabled();
+    void sigServerBlocked();
+    void sigStartCompare(QList<FileData> *serverStreamingHash, QList<FileData> localStreamingHash);
+    void sigShowUpdateList();
+    void sigCallUpdateList();
+    void sigShowServerList(QList<StreamingVersionData *> *serverData);
+    void sigSaveLoginData(ServerAuthorization *serverAuth);
+
+
+private:
+    HashComparer *hashComparer;
+    VersionContainer *versionContainer;
+    UpdateController * updateController;
+    DataParserOutput *dataParserOutput;
+};
+
+#endif // POSTPROCESSORSYSTEM_H

Core/recognizesystem.cpp

@@ -1,5 +1,6 @@
 #include "Core/recognizesystem.h"
 
+
 RecognizeSystem::RecognizeSystem(QObject *parent):
     QObject(parent)
 {
@@ -18,30 +19,10 @@ RecognizeSystem::~RecognizeSystem()
 
 }
 
-void RecognizeSystem::initialize(UpdateController *updateController,
+void RecognizeSystem::initialize(VersionContainer *versionContainer,PostProcessorSystem *postProcessorSystem)
-                                 DataParser *dataParser,
-                                 MainWindow *mainWindow,
-                                 HashComparer *hashComparer,
-                                 TCPClient *client,
-                                 VersionContainer* versionContainer)
 {
-    this->updateController = updateController;
-    this->dataParser = dataParser;
-    this->mainWindow = mainWindow;
     this->versionContainer = versionContainer;
-
+    this->postProcessorSystem = postProcessorSystem;
-    connect(this,&RecognizeSystem::sigSaveLoginData,dataParser,&DataParser::createAuthData);
-    connect(this,&RecognizeSystem::sigStartCompare,hashComparer,&HashComparer::CompareDeltas);
-    connect(this,&RecognizeSystem::sigUpdateBytesAvailable,mainWindow,&MainWindow::updateProgress,Qt::AutoConnection); //todo autoConnection?
-    connect(this,&RecognizeSystem::sigLoadComplete,mainWindow,&MainWindow::loadComplete);
-    connect(this,&RecognizeSystem::sigNeedUpdate,mainWindow,&MainWindow::setNeedUpdate);
-    connect(this,&RecognizeSystem::sigSocketDisabled,mainWindow,&MainWindow::lostConnection);
-    connect(this,&RecognizeSystem::sigSaveLoginData,mainWindow,&MainWindow::checkLoginResult); //TODO: прибратся! 2 бинда на 1 сигнал
-    connect(this,&RecognizeSystem::sigSocketWaitForReadyRead,client,&TCPClient::waitRead,Qt::DirectConnection);
-    connect(this,&RecognizeSystem::sigServerBlocked,mainWindow,&MainWindow::serverBlocked);
-    connect(this,&RecognizeSystem::sigShowServerList,mainWindow,&MainWindow::showServerListWidget);
-    connect(this,&RecognizeSystem::sigAnimationActivated,mainWindow,&MainWindow::activateLoadingAnimation,Qt::AutoConnection);
-    connect(this,&RecognizeSystem::sigShowUpdateList,mainWindow,&MainWindow::showUpdateInfo,Qt::AutoConnection);
 }
 
 void RecognizeSystem::recognize(QTcpSocket *socket)
@@ -153,7 +134,8 @@ void RecognizeSystem::recognize(QTcpSocket *socket)
                 if(!stream.commitTransaction()){
 
                     if(socket->state() == QAbstractSocket::UnconnectedState){
-                        emit sigSocketDisabled();
+                        postProcessorSystem->socketDisable();
+                        //emit sigSocketDisabled();
                         return;
                     }
                     if(socket->waitForReadyRead(TCP_READ_TIMEOUT)){
@@ -229,7 +211,8 @@ void RecognizeSystem::recognize(QTcpSocket *socket)
 
         if (packetType ==PacketType::TYPE_FINISH) //для повторного создания хэша после загрузки
         {
-            updateController->calculateCommonHash();
+            postProcessorSystem->calculateCommonHash();
+
             emit sigLoadComplete();
             packetType = PacketType::TYPE_NONE;
         }
@@ -271,12 +254,14 @@ void RecognizeSystem::recognize(QTcpSocket *socket)
 
         if(packetType == PacketType::HASH_READY)
         {
-           mainWindow->checkUpdate();
+            emit sigCheckUpdate();
+           //mainWindow->checkUpdate();
         }
 
         if(packetType == PacketType::HASH_CALCULATE_START)
         {
-            mainWindow->setInlineDebug(tr("Пересчет хэша на сервере..."));
+            emit sigSetInineDebug(tr("Пересчет хэша на сервере..."));
+            //mainWindow->setInlineDebug();
         }
 
         if(packetType == PacketType::BUSY)
@@ -292,21 +277,3 @@ void RecognizeSystem::recognize(QTcpSocket *socket)
         packetType = PacketType::TYPE_NONE;
     }
 }
-
-void RecognizeSystem::checkAccessType(QString type)
-{
-    if(type == "instructor")
-    {
-        mainWindow->callUpdateList();
-    }
-}
-
-void RecognizeSystem::setServerVersion(StreamingVersionData *serverVersion)
-{
-     versionContainer->setServerVersionData(serverVersion);
-}
-
-void RecognizeSystem::showServerDataList(QList<StreamingVersionData*> *showServerDataList)
-{
-    //emit sigShowServerList(showServerDataList);
-}

Core/recognizesystem.h

@@ -1,19 +1,18 @@
 #ifndef RECOGNIZESYSTEM_H
 #define RECOGNIZESYSTEM_H
 
+#include "Core/dataparser.h"
+#include "Core/postprocessorsystem.h"
 #include <QObject>
 #include <QDataStream>
 #include <QTcpSocket>
-#include <mainwindow.h>
-#include <Core\tools.h>
-#include <Core\UpdateController.h>
-#include <Data\streamingversiondata.h>
-#include <Widgets\updatenotifywidget.h>
 
-class UpdateController;
+#include <QThread>
-class MainWindow;
+#include <Core\tools.h>
-class HashComparer;
+#include <Core\versioncontainer.h>
-class TCPClient;
+#include <Data\streamingversiondata.h>
+#include <Core\hashcomparer.h>
+
 class ServerAuthorization;
 
 class RecognizeSystem : public QObject
@@ -24,16 +23,9 @@ class RecognizeSystem : public QObject
 public:
     explicit RecognizeSystem(QObject *parent = 0);
     ~RecognizeSystem();
-    void initialize(UpdateController* updateController,
+    void initialize(VersionContainer* versionContainer,PostProcessorSystem *postProcessorSystem);
-                    DataParser *dataParser,
-                    MainWindow *mainWindow,
-                    HashComparer *hashComparer,
-                    TCPClient *client,
-                    VersionContainer* versionContainer);
 
     void recognize(QTcpSocket *socket);
-    void checkAccessType(QString type);
-    void setServerVersion(StreamingVersionData *serverVersion);
     void showServerDataList(QList<StreamingVersionData*> *showServerDataList);
 
 signals:
@@ -41,21 +33,16 @@ signals:
     void sigLoadComplete();
     void sigNeedUpdate(bool flag,qint64 size,quint64 fileCount,quint64 fileDelete);
     void sigSendDebugLog(QString message);
-    void sigSocketDisabled();
-    void sigServerBlocked();
-    void sigSaveLoginData(ServerAuthorization *serverAuth);
     void sigSocketWaitForReadyRead(int waitTime);
-    void sigStartCompare();
-    void sigShowServerList(QList<StreamingVersionData*> *serverDatas);
     void sigAnimationActivated(bool flag);
-    void sigShowUpdateList();
+    void sigCheckUpdate();
+    void sigSetInineDebug(QString message);
 
 private:
     QList<QString> *folderList;
-    MainWindow *mainWindow;
-    UpdateController *updateController;
-    DataParser *dataParser;
     VersionContainer *versionContainer;
+    DataParser *dataParser;
+    PostProcessorSystem *postProcessorSystem;
     PacketType packetType;
     QString message;
     QString filePath;

Core/screenchecker.cpp

@@ -1,13 +1,13 @@
 #include "screenchecker.h"
 #include <windows.h>
 
-ScreenChecker::ScreenChecker(QWidget *mainWidget,DataParser *dataParser, QHBoxLayout *layout, QObject *parent) :
+ScreenChecker::ScreenChecker(QWidget *mainWidget,DataParserOutput *dataParserOut, QHBoxLayout *layout, QObject *parent) :
     QObject(parent)
 {
     screenCount = 0;
     this->mainWidget = mainWidget;
     this->layout = layout;
-    this->dataParser = dataParser;
+    this->dataParserOutput = dataParserOut;
 }
 
 void ScreenChecker::check()
@@ -121,7 +121,7 @@ void ScreenChecker::updateDisplayData()
     if (displaysIndexList->at(0) != 0)
         displaysIndexList->replace(0,0);
 
-    dataParser->addRunData(*displaysIndexList);
+    dataParserOutput->addRunData(*displaysIndexList);
 }
 
 QString ScreenChecker::getScreenCount() const

Core/screenchecker.h

@@ -1,8 +1,7 @@
 #ifndef SCREENCHECKER_H
 #define SCREENCHECKER_H
 
-#include "dataparser.h"
+#include "Core/dataparseroutput.h"
-
 #include <QObject>
 #include <QScreen>
 #include <QGuiApplication>
@@ -23,7 +22,7 @@ class ScreenChecker : public QObject
     Q_OBJECT
 
 public:
-    explicit ScreenChecker(QWidget *widget,DataParser *dataParser, QHBoxLayout *layout,QObject *parent = nullptr);
+    explicit ScreenChecker(QWidget *widget,DataParserOutput *dataParserOutput, QHBoxLayout *layout,QObject *parent = nullptr);
     ~ScreenChecker();
     void check();
     QString getScreenCount() const;
@@ -31,8 +30,8 @@ public:
 
 private:
     QWidget *mainWidget;
-    DataParser *dataParser;
     QWidget *widget;
+    DataParserOutput *dataParserOutput;
     QHBoxLayout *layout;
     qint64 screenCount;
     QList<QScreen *> screens;

Core/sendsystem.cpp

@@ -2,13 +2,6 @@
 
 SendSystem::SendSystem(QObject *) {}
 
-void SendSystem::initialize(MainWindow *mainWindow,DataParser *dataParser)
-{
-    this->mainWindow = mainWindow;
-    connect(this,&SendSystem::sigSend,mainWindow,&MainWindow::updateProgress);
-    connect(this,&SendSystem::sigGetXmlAnswer,dataParser,&DataParser::xmlAnswer_notify,Qt::DirectConnection);   //МОЖЕТ ДАТУ ПАРСЕР В ВТОРОСТЕПЕННЫЙ ПОТОК?
-}
-
 void SendSystem::setSocket(QTcpSocket *socket)
 {
     this->socket = socket;

Core/sendsystem.h

@@ -7,19 +7,13 @@
 #include <QThread>
 #include <QTcpSocket>
 #include <QDataStream>
-#include <mainwindow.h>
 #include <Core/tools.h>
 
-class MainWindow;
-class DataParser;
-class Tools;
-
 class SendSystem :public QObject
 {
     Q_OBJECT
 public:
     explicit SendSystem(QObject* parent = nullptr);
-    void initialize(MainWindow *mainWindow,DataParser *dataParser);
     void setSocket(QTcpSocket *socket);
     void sendClientAutorization();
     void sendDisable();
@@ -44,7 +38,6 @@ public slots:
     void xmlAnswer(QString message);
 private:
     QTcpSocket *socket;
-    MainWindow *mainWindow;
 
 };
 

Core/tcpclient.cpp

@@ -5,15 +5,14 @@ TCPClient::TCPClient(QObject *parent) :
 {
 }
 
-void TCPClient::initialize(MainWindow *mainWindow,RecognizeSystem *recognize,ExternalExecuter *externalExecuter,SendSystem *sendSystem)
+void TCPClient::initialize(RecognizeSystem *recognize,ExternalExecuter *externalExecuter,SendSystem *sendSystem)
 {
     this->recognizeSystem = recognize;
     this->externalExecuter = externalExecuter;
     this->sendSystem = sendSystem;
     isConnected = false;
 
-    connect(this,&TCPClient::sigConnectionState,mainWindow,&MainWindow::slotConnectionState,Qt::AutoConnection);
+    connect(recognize,&RecognizeSystem::sigSocketWaitForReadyRead,this,&TCPClient::waitRead,Qt::DirectConnection);
-    connect(this,&TCPClient::sigServerDisconnect,mainWindow,&MainWindow::slotServerDisconnect);
 
     emit sigSendDebugLog(Tools::getTime() + " Client started");
 }

Core/tcpclient.h

@@ -1,6 +1,7 @@
 #ifndef TCPCLIENT_H
 #define TCPCLIENT_H
 
+#include "Core/sendsystem.h"
 #include <QObject>
 #include <QTcpSocket>
 #include <QHostAddress>
@@ -11,14 +12,11 @@
 #include <QCoreApplication>
 #include <Core\recognizesystem.h>
 #include <Core\tools.h>
-#include <Core\UpdateController.h>
 #include <Core\externalexecuter.h>
 
 
 class UpdateController;
 class RecognizeSystem;
-class SendSystem;
-class MainWindow;
 class ServerSettings;
 
 class TCPClient : public QObject
@@ -28,7 +26,7 @@ class TCPClient : public QObject
 
 public:
     explicit TCPClient(QObject *parent = 0);
-    void initialize(MainWindow *mainWindow,RecognizeSystem *recognize,ExternalExecuter *externalExecuter,SendSystem *sendSystem);
+    void initialize(RecognizeSystem *recognize,ExternalExecuter *externalExecuter,SendSystem *sendSystem);
     void setConnect(ServerSettings *serverSettings);
 
     void waitRead(int time);

Core/versioncontainer.h

@@ -14,7 +14,6 @@ public:
     QString getServerVersion() const;
     QString getLocalVersion() const;
 
-
     StreamingVersionData *getLocalVersionData() const;
     void setLocalVersionData(StreamingVersionData *value);
 

RRJClient.pro

@@ -18,7 +18,9 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 
 SOURCES += \
+    Core/dataparseroutput.cpp \
     Core/notifycontroller.cpp \
+    Core/postprocessorsystem.cpp \
     Core/sendsystem.cpp \
     Core/versioncontainer.cpp \
     Core\updatecontroller.cpp \
@@ -42,7 +44,9 @@ SOURCES += \
     Widgets\versionselectwidget.cpp \
 
 HEADERS += \
+    Core/dataparseroutput.h \
     Core/notifycontroller.h \
+    Core/postprocessorsystem.h \
     Core/versioncontainer.h \
     Core\sendsystem.h \
     Core\updatecontroller.h \

Widgets/commonbuttongroupwidget.cpp

@@ -8,11 +8,10 @@ CommonButtonGroupWidget::CommonButtonGroupWidget(QWidget *parent) :
     ui->setupUi(this);
 }
 
-void CommonButtonGroupWidget::initialize(MainWindow *mainWindow,ExternalExecuter *extExec,SendSystem *sendSystem,TCPClient *client)
+void CommonButtonGroupWidget::initialize(ExternalExecuter *extExec,SendSystem *sendSystem,TCPClient *client)
 {
     externalExecuter = extExec;
     this->sendSystem = sendSystem;
-    this->mainWindow = mainWindow;
     ui->loadingProgressBar->setValue(0);
     ui->loadingProgressBar->hide();
     ui->updateButton->hide();
@@ -84,8 +83,8 @@ void CommonButtonGroupWidget::on_updateButton_clicked()
 {
     emit sigSendPacket(PacketType::TYPE_UPDATE);
     startUpdateState();
-    mainWindow->disableUnsaveButton(true);
+    emit sigUpdateCommonWidget();
-    mainWindow->setInlineDebug(tr("Загрузка..."));
+
 }
 
 void CommonButtonGroupWidget::on_startButton_clicked()

Widgets/commonbuttongroupwidget.h

@@ -18,7 +18,7 @@ class CommonButtonGroupWidget : public QWidget
 
 public:
     explicit CommonButtonGroupWidget(QWidget *parent = nullptr);
-    void initialize(MainWindow *mainWindow,ExternalExecuter *extExec,SendSystem *sendSystem,TCPClient *client);
+    void initialize(ExternalExecuter *extExec,SendSystem *sendSystem,TCPClient *client);
     void loadCompleteState();
     void lastVerInstalledState();
     void disconnectState();
@@ -31,6 +31,7 @@ public:
 signals:
     void sigSendPacket(PacketType packet);
     void sigSendXMLAnswer(QString answer);
+    void sigUpdateCommonWidget();
 
 private slots:
     void on_updateButton_clicked();
@@ -41,7 +42,6 @@ public:
 
 private:
     Ui::CommonButtonGroupWidget *ui;
-    MainWindow *mainWindow;
     ExternalExecuter *externalExecuter;
     SendSystem *sendSystem;
 };

Widgets/entrywidget.cpp

@@ -8,13 +8,11 @@ EntryWidget::EntryWidget(QWidget *parent) :
     ui->setupUi(this);
 }
 
-void EntryWidget::initialize(MainWindow *mainWindow)
+void EntryWidget::initialize()
 {
     ui->offlineWidget->hide();
     ui->loginWidget->hide();
     ui->settingsWidget->hide();
-    this->mainWindow = mainWindow;
-
 }
 
 void EntryWidget::connectionEmptyState()
@@ -58,12 +56,12 @@ void EntryWidget::loginIsActive(bool flag)
 
 void EntryWidget::on_loginButton_clicked()
 {
-    mainWindow->login();
+    emit sigTryLogin();
 }
 
 void EntryWidget::on_saveServerButton_clicked()
 {
-    mainWindow->saveServerSettingsWithConnect();
+    emit sigSaveServerSettings();
 }
 
 ServerSettings *EntryWidget::getServerSettings()

Widgets/entrywidget.h

@@ -1,7 +1,6 @@
 #ifndef ENTRYWIDGET_H
 #define ENTRYWIDGET_H
 
-#include "mainwindow.h"
 #include <QWidget>
 #include <Data/Datas.h>
 
@@ -15,7 +14,7 @@ class EntryWidget : public QWidget
 
 public:
     explicit EntryWidget(QWidget *parent = nullptr);
-    void initialize(MainWindow *mainWindow);
+    void initialize();
     void AconnectionEmptyState();
     void settingsState();
     bool isLoginFieldsFill();
@@ -27,14 +26,17 @@ public:
     void fillSettings(ServerSettings *settings);
     ServerSettings *getServerSettings();
     void isActive(bool flag);
+
+signals:
+    void sigTryLogin();
+    void sigSaveServerSettings();
+
 private slots:
     void on_loginButton_clicked();
-
     void on_saveServerButton_clicked();
 
 private:
     Ui::EntryWidget *ui;
-    MainWindow *mainWindow;
 };
 
 #endif // ENTRYWIDGET_H

Widgets/instructorbuttongroupwidget.cpp

@@ -10,29 +10,26 @@ InstructorButtonGroupWidget::InstructorButtonGroupWidget(QWidget *parent) :
     ui->setupUi(this);
 }
 
-void InstructorButtonGroupWidget::initialize(MainWindow *mainWindow)
+void InstructorButtonGroupWidget::initialize()
 {
-    this->mainWindow = mainWindow;
     hide();
 }
 
 void InstructorButtonGroupWidget::on_loadToServerButton_clicked()
 {
-    mainWindow->loadToServer();
+    emit sigLoadToServer();
 }
 
 void InstructorButtonGroupWidget::on_undoChangesButton_clicked()
 {
-    mainWindow->undoCurrentChanges();
+    emit sigUndoCurrentChanges();
 }
 
 void InstructorButtonGroupWidget::on_startWithCurrentChangesButton_clicked()
 {
-    mainWindow->startUnityClient();
+    emit sigStartUnityClient();
 }
 
-
-
 InstructorButtonGroupWidget::~InstructorButtonGroupWidget()
 {
     delete ui;

Widgets/instructorbuttongroupwidget.h

@@ -2,33 +2,31 @@
 #define INSTRUCTORBUTTONGROUPWIDGET_H
 
 #include <QWidget>
-#include "mainwindow.h"
 
 namespace Ui {
 class InstructorButtonGroupWidget;
 }
 
-class MainWindow;
-
 class InstructorButtonGroupWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     explicit InstructorButtonGroupWidget(QWidget *parent = nullptr);
-    void initialize(MainWindow *mainWindow);
+    void initialize();
 
     ~InstructorButtonGroupWidget();
+signals:
+    void sigLoadToServer();
+    void sigUndoCurrentChanges();
+    void sigStartUnityClient();
 private slots:
     void on_loadToServerButton_clicked();
-
     void on_undoChangesButton_clicked();
-
     void on_startWithCurrentChangesButton_clicked();
 
 private:
     Ui::InstructorButtonGroupWidget *ui;
-    MainWindow *mainWindow;
 };
 
 #endif // INSTRUCTORBUTTONGROUPWIDGET_H

Widgets/newversionwidget.cpp

@@ -10,9 +10,8 @@ NewVersionWidget::NewVersionWidget(QWidget *parent) :
     setAttribute(Qt::WA_ShowModal,true);
 }
 
-void NewVersionWidget::initialize(VersionSelectWidget *versionSelectWidget, QString prevName)
+void NewVersionWidget::initialize(QString prevName)
 {
-    this->versionSelectWidget = versionSelectWidget;
     ui->prevVerValue->setText(prevName);
 }
 
@@ -21,7 +20,7 @@ void NewVersionWidget::on_createButton_clicked()
 {
     if(ui->lineEdit->text() != "")
     {
-        versionSelectWidget->sendCopyEmit(ui->lineEdit->text());
+        emit sigSendCopy(ui->lineEdit->text());
         hide();
     }
 }

Widgets/newversionwidget.h

@@ -1,23 +1,24 @@
 #ifndef NEWVERSIONWIDGET_H
 #define NEWVERSIONWIDGET_H
 
-#include <Widgets/versionselectwidget.h>
 #include <QWidget>
 
 namespace Ui {
 class NewVersionWidget;
 }
 
-class VersionSelectWidget;
 class NewVersionWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     explicit NewVersionWidget(QWidget *parent = nullptr);
-    void initialize(VersionSelectWidget *versionSelectWidget,QString prevName);
+    void initialize(QString prevName);
     ~NewVersionWidget();
 
+signals:
+    void sigSendCopy(QString copyName);
+
 private slots:
     void on_createButton_clicked();
 
@@ -25,7 +26,6 @@ private slots:
 
 private:
     Ui::NewVersionWidget *ui;
-    VersionSelectWidget *versionSelectWidget;
 };
 
 #endif // NEWVERSIONWIDGET_H

Widgets/updatenotifywidget.cpp

@@ -1,6 +1,6 @@
 #include "updatenotifywidget.h"
 #include "ui_updatenotifywidget.h"
-#include "mainwindow.h"
+#include "Core/tools.h"
 
 #include <QMessageBox>
 
@@ -12,14 +12,13 @@ UpdateNotifyWidget::UpdateNotifyWidget(QWidget *) :
 //    setAttribute(Qt::WA_ShowModal,true);
 }
 
-void UpdateNotifyWidget::initialize(MainWindow *mainWindow,VersionContainer *verContainer)
+void UpdateNotifyWidget::initialize(VersionContainer *verContainer,QPoint startPos)
 {
-    this->mainWindow = mainWindow;
     this->versionContainer = verContainer;
     currentLoadingCount = 0;
     hide();
 
-    auto pos = mainWindow->pos();
+    QPoint pos = startPos;
     pos.setY(pos.y() + 40);
     move(pos);
 }
@@ -101,17 +100,17 @@ QLabel* UpdateNotifyWidget::createLabel(QString text)
 }
 void UpdateNotifyWidget::on_loadToServerButton_clicked()
 {
-    mainWindow->loadToServer();
+    emit sigLoadToServerBehaviour();
 }
 
 void UpdateNotifyWidget::on_undoChangesButton_clicked()
 {
-    mainWindow->undoCurrentChanges();
+    emit sigUndoCurrentChanges();
 }
 
 void UpdateNotifyWidget::on_startWithCurrentChangesButton_clicked()
 {
-    mainWindow->startUnityClient();
+    emit sigStartUnityClient();
 }
 
 void UpdateNotifyWidget::setUpdateState()
@@ -136,11 +135,6 @@ UpdateNotifyWidget::~UpdateNotifyWidget()
 
 void UpdateNotifyWidget::on_closeButton_clicked()
 {
-    mainWindow->showMainFrame(true);
+    emit sigShowMainFrame(true);
     close();
 }
-
-void UpdateNotifyWidget::on_updateActionListLabel_linkActivated(const QString &link)
-{
-
-}

Widgets/updatenotifywidget.h

@@ -1,22 +1,17 @@
 #ifndef UPDATENOTIFYWIDGET_H
 #define UPDATENOTIFYWIDGET_H
 
-#include "mainwindow.h"
-
 #include <QDialog>
 #include <QWidget>
 #include <QLabel>
 
 #include <Data/FileData.h>
+#include <Core/versioncontainer.h>
 
 namespace Ui {
 class UpdateNotifyWidget;
 }
-
-class MainWindow;
-class UpdateController;
 class InstructorButtonGroupWidget;
-class VersionContainer;
 
 class UpdateNotifyWidget : public QWidget
 {
@@ -24,7 +19,7 @@ class UpdateNotifyWidget : public QWidget
 
 public:
     explicit UpdateNotifyWidget(QWidget *parent = nullptr);
-    void initialize(MainWindow *mainWindow,VersionContainer *versionContainer);
+    void initialize(VersionContainer *versionContainer,QPoint startPos);
     void addToList(FileData fileData);
     void showWithFill();
 
@@ -32,17 +27,20 @@ public:
 
     void showTryChangeBase();
 
+signals:
+    void sigLoadToServerBehaviour();
+    void sigUndoCurrentChanges();
+    void sigStartUnityClient();
+    void sigShowMainFrame(bool flag);
+
 private slots:
     void on_closeButton_clicked();
     void on_loadToServerButton_clicked();
     void on_undoChangesButton_clicked();
     void on_startWithCurrentChangesButton_clicked();
 
-    void on_updateActionListLabel_linkActivated(const QString &link);
-
 private:
     Ui::UpdateNotifyWidget *ui;
-    MainWindow *mainWindow;
     VersionContainer *versionContainer;
     int currentLoadingCount;
     QLabel* createLabel(QString text);

Widgets/versionselectwidget.cpp

@@ -1,6 +1,6 @@
 #include "versionselectwidget.h"
 #include "ui_versionselectwidget.h"
-#include "ui_versionselectwidget.h"
+#include "Widgets/newversionwidget.h"
 
 #include <QMessageBox>
 
@@ -49,12 +49,13 @@ void VersionSelectWidget::on_verListView_itemDoubleClicked(QListWidgetItem *item
     }
 }
 
-
 void VersionSelectWidget::on_createDuplicateButton_clicked()
 {
     NewVersionWidget *newVersionWidget = new NewVersionWidget;
-    newVersionWidget->initialize(this,selectedVersion->getViewName());
+    newVersionWidget->initialize(selectedVersion->getViewName());
     newVersionWidget->show();
+
+    connect(newVersionWidget,&NewVersionWidget::sigSendCopy,this,&VersionSelectWidget::sendCopyEmit);
 }
 
 void VersionSelectWidget::sendCopyEmit(QString newName)

Widgets/versionselectwidget.h

@@ -4,10 +4,10 @@
 #include <QListWidget>
 #include <QWidget>
 
+#include <Core/notifycontroller.h>
 #include <Core/sendsystem.h>
+#include <Core/versioncontainer.h>
 #include <Data/streamingversiondata.h>
-#include <Widgets/newversionwidget.h>
-
 namespace Ui {
 class VersionSelectWidget;
 }
@@ -21,7 +21,6 @@ public:
 
     void initialize(SendSystem *sendSystem,VersionContainer *versionContainer,NotifyController *notifyController);
     void fillView(QList<StreamingVersionData*> *serverData);
-    void sendCopyEmit(QString newName);
 
     ~VersionSelectWidget();
 private slots:
@@ -29,6 +28,7 @@ private slots:
     void on_createDuplicateButton_clicked();
     void on_DeleteVersionButton_clicked();
     void on_switchServerVersionButton_clicked();
+    void sendCopyEmit(QString newName);
 
 signals:
     void sigSendDeleteVersion(StreamingVersionData *streaming);

mainwindow.cpp

@@ -51,16 +51,22 @@ void MainWindow::createObjects()
     dataParser = new DataParser;
     dataParser->moveToThread(workerThread);
 
+    dataParserOutput = new DataParserOutput;
+    dataParser->moveToThread(workerThread);
+
     sendSystem = new SendSystem;
     sendSystem->moveToThread(workerThread);
 
-    updateController = new UpdateController(dataParser,sendSystem);
+    updateController = new UpdateController(dataParserOutput,sendSystem);
     updateController->moveToThread(workerThread);
 
     recognizeSystem = new RecognizeSystem;
     recognizeSystem->moveToThread(workerThread);
 
-    screenChecker = new ScreenChecker(this,dataParser,ui->displayLayout);
+    postProcessorSystem = new PostProcessorSystem;
+    postProcessorSystem->moveToThread(workerThread);
+
+    screenChecker = new ScreenChecker(this,dataParserOutput,ui->displayLayout);
     externalExecuter = new ExternalExecuter;
 
     hashComparer = new HashComparer(dataParser);
@@ -73,8 +79,6 @@ void MainWindow::createObjects()
     workerThread->setPriority(QThread::HighestPriority);
 
     timer = new QTimer;
-
-
 }
 
 void MainWindow::paintEvent(QPaintEvent* event) {
@@ -99,16 +103,15 @@ void MainWindow::initialize()
     loadStaticData();
     bindConnection();
 
-    updateWidget->initialize(this,versionContainer);
+    updateWidget->initialize(versionContainer,pos());
-    entryWidget->initialize(this);
+    entryWidget->initialize();
     versionSelectWidget->initialize(sendSystem,versionContainer,notifyController);
-    hashComparer->initialize(this,versionContainer);
+    hashComparer->initialize(versionContainer);
-    updateController->initialize(this,versionContainer);
+    updateController->initialize(versionContainer);
-    sendSystem->initialize(this,dataParser);
+    dataParser->initialize();
-    dataParser->initialize(recognizeSystem,notifyController,updateController,hashComparer);
+    recognizeSystem->initialize(versionContainer,postProcessorSystem);
-    recognizeSystem->initialize(updateController,dataParser,this,hashComparer,client,versionContainer);
     resourceManager->painting();
-    commonButtonGroupWidget->initialize(this,externalExecuter,sendSystem,client);
+    commonButtonGroupWidget->initialize(externalExecuter,sendSystem,client);
     commonButtonGroupWidget->show();
     ui->LanguageWidget->hide();
 
@@ -116,7 +119,7 @@ void MainWindow::initialize()
 
     setInlineDebug(tr("Инициализация..."));
     emit sigCalculateHash();
-    emit sigInitializeClient(this,recognizeSystem,externalExecuter,sendSystem,workerThread);
+    emit sigInitializeClient(recognizeSystem,externalExecuter,sendSystem);
 
     screenChecker->check();
 
@@ -144,7 +147,53 @@ void MainWindow::bindConnection()
     connect(this,&MainWindow::sigSendCheckUpdate,updateController,&UpdateController::checkCanUpdate,Qt::AutoConnection);
     connect(this,&MainWindow::sigGetConnected,client,&TCPClient::getIsConnected);
     connect(this,&MainWindow::sigCalculateHash,updateController,&UpdateController::calculateCommonHash);
+
+    connect(postProcessorSystem,&PostProcessorSystem::sigCallUpdateList,this,&MainWindow::callUpdateList,Qt::AutoConnection);
+    connect(postProcessorSystem,&PostProcessorSystem::sigSocketDisabled,this,&MainWindow::lostConnection,Qt::AutoConnection);
+    connect(postProcessorSystem,&PostProcessorSystem::sigServerBlocked,this,&MainWindow::serverBlocked,Qt::AutoConnection);
+    connect(postProcessorSystem,&PostProcessorSystem::sigStartCompare,hashComparer,&HashComparer::CompareDeltas,Qt::AutoConnection); // ОПАСНОСТЬ
+    connect(postProcessorSystem,&PostProcessorSystem::sigSaveLoginData,this,&MainWindow::checkLoginResult,Qt::AutoConnection);
+    connect(postProcessorSystem,&PostProcessorSystem::sigSaveLoginData,dataParserOutput,&DataParserOutput::createAuthData,Qt::AutoConnection);
+    connect(postProcessorSystem,&PostProcessorSystem::sigShowServerList,this,&MainWindow::showServerListWidget);
+    connect(postProcessorSystem,&PostProcessorSystem::sigShowUpdateList,this,&MainWindow::showUpdateInfo,Qt::AutoConnection);
+
     connect(versionContainer,&VersionContainer::sigSetServerVersion,this,&MainWindow::setServerVersion);
+
+    connect(recognizeSystem,&RecognizeSystem::sigUpdateBytesAvailable,this,&MainWindow::updateProgress,Qt::AutoConnection);
+    connect(recognizeSystem,&RecognizeSystem::sigLoadComplete,this,&MainWindow::loadComplete);
+    connect(recognizeSystem,&RecognizeSystem::sigNeedUpdate,this,&MainWindow::setNeedUpdate);
+    connect(recognizeSystem,&RecognizeSystem::sigCheckUpdate,this,&MainWindow::checkUpdate,Qt::AutoConnection);
+    connect(recognizeSystem,&RecognizeSystem::sigSetInineDebug,this,&MainWindow::setInlineDebug,Qt::AutoConnection);
+
+    connect(recognizeSystem,&RecognizeSystem::sigAnimationActivated,this,&MainWindow::activateLoadingAnimation,Qt::AutoConnection);
+
+    connect(updateWidget,&UpdateNotifyWidget::sigLoadToServerBehaviour,this,&MainWindow::loadToServer,Qt::AutoConnection);
+    connect(updateWidget,&UpdateNotifyWidget::sigUndoCurrentChanges,this,&MainWindow::undoCurrentChanges,Qt::AutoConnection);
+    connect(updateWidget,&UpdateNotifyWidget::sigStartUnityClient,this,&MainWindow::startUnityClient,Qt::AutoConnection);
+    connect(updateWidget,&UpdateNotifyWidget::sigShowMainFrame,this,&MainWindow::showMainFrame,Qt::AutoConnection);
+
+    connect(hashComparer,&HashComparer::sigCallCheck,this,&MainWindow::checkUpdate);
+    connect(hashComparer,&HashComparer::sigHaveDelta,this,&MainWindow::showUpdateInfo);
+
+    connect(updateController,&UpdateController::sigUpdateComplete,this,&MainWindow::showCompleteDialogBox);
+
+    connect(client,&TCPClient::sigConnectionState,this,&MainWindow::slotConnectionState,Qt::AutoConnection);
+    connect(client,&TCPClient::sigServerDisconnect,this,&MainWindow::slotServerDisconnect);
+
+    connect(sendSystem,&SendSystem::sigSend,this,&MainWindow::updateProgress);
+
+    connect(sendSystem,&SendSystem::sigGetXmlAnswer,dataParserOutput,&DataParserOutput::xmlAnswer_notify,Qt::DirectConnection);//ОПАСНОСТЬ
+
+    connect(commonButtonGroupWidget,&CommonButtonGroupWidget::sigUpdateCommonWidget,this,&MainWindow::commonWidgetState);
+    connect(entryWidget,&EntryWidget::sigTryLogin,this,&MainWindow::login,Qt::AutoConnection);
+    connect(entryWidget,&EntryWidget::sigSaveServerSettings,this,&MainWindow::saveServerSettingsWithConnect,Qt::AutoConnection);
+
+    connect(instructorButtonGroup,&InstructorButtonGroupWidget::sigLoadToServer,this,&MainWindow::loadToServer, Qt::AutoConnection);
+    connect(instructorButtonGroup,&InstructorButtonGroupWidget::sigUndoCurrentChanges,this,&MainWindow::undoCurrentChanges, Qt::AutoConnection);
+    connect(instructorButtonGroup,&InstructorButtonGroupWidget::sigStartUnityClient,this,&MainWindow::startUnityClient, Qt::AutoConnection);
+
+    connect(dataParser,&DataParser::sigNotify,notifyController,&NotifyController::showWarning,Qt::AutoConnection);//ОПАСНОСТЬ
+    connect(dataParser,&DataParser::sigUpdateFilesOnServer,updateController,&UpdateController::updateFilesOnServer,Qt::AutoConnection);//ОПАСНОСТЬ
 }
 
 void MainWindow::updateProgress()
@@ -164,7 +213,7 @@ void MainWindow::loadComplete()
     ui->autostartCheckBox->hide();
     ui->offlineStartButton->show();
 
-    dataParser->changeVersion(versionContainer->getServerVersionData());
+    dataParserOutput->changeVersion(versionContainer->getServerVersionData());
     setTitle();
 }
 
@@ -206,7 +255,7 @@ void MainWindow::setNeedUpdate(bool flag,quint64 size, quint64 fileCount,quint64
         commonButtonGroupWidget->lastVerInstalledState();
         ui->unsafeChangingButton->hide();
         ui->offlineStartButton->setEnabled(true);
-        dataParser->changeVersion(versionContainer->getServerVersionData());
+        dataParserOutput->changeVersion(versionContainer->getServerVersionData());
         activateLoadingAnimation(false);
         setTitle();
     }
@@ -251,7 +300,7 @@ void MainWindow::checkLoginResult(ServerAuthorization *serverAuth)
             emit sigSendXMLAnswer(cmd_CheckVersionList);
         }
 
-        dataParser->createAuthData(serverAuth);
+        dataParserOutput->createAuthData(serverAuth);
         entryWidget->loginIsActive(false);
         //ui->LanguageWidget->hide();
         ui->settingsButton->hide();
@@ -411,7 +460,7 @@ void MainWindow::login()
 
     entryWidget->loginIsActive(false);
     ClientAutorization *autorization = entryWidget->getAuthData();
-    dataParser->createAuthMessage(autorization);
+    dataParserOutput->createAuthMessage(autorization);
     emit sigSendAutorization();
 
 }
@@ -422,7 +471,7 @@ void MainWindow::saveServerSettingsWithConnect()
     entryWidget->isActive(false);
     ServerSettings *settings = entryWidget->getServerSettings();
     settings->LocalVersionName = dataParser->getClientSettings()->LocalVersionName;
-    dataParser->createServerSettings(settings);
+    dataParserOutput->createServerSettings(settings);
 
     if(client->getIsConnected())
     {
@@ -449,7 +498,7 @@ void MainWindow::on_settingsButton_clicked()
 void MainWindow::on_languageComboBox_activated(const QString &arg1)
 {
     qDebug() << arg1;
-    dataParser->saveClientSettrings(arg1,ui->autostartCheckBox->isChecked());
+    dataParserOutput->saveClientSettrings(arg1,ui->autostartCheckBox->isChecked());
     checkLanguage(arg1);
     ui->retranslateUi(this);
 }
@@ -577,6 +626,12 @@ void MainWindow::setUpUi()
     activateLoadingAnimation(true);
 }
 
+void MainWindow::commonWidgetState()
+{
+    disableUnsaveButton(true);
+    setInlineDebug(tr("Загрузка..."));
+}
+
 void MainWindow::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return)
@@ -630,7 +685,7 @@ void MainWindow::on_offlineStartButton_clicked()
     QString username = "offlineUser";
     QString password = "000000";
 
-    dataParser->createAuthDataOffline(username,password);
+    dataParserOutput->createAuthDataOffline(username,password);
     startUnityClient();
 
 

mainwindow.h

@@ -27,18 +27,6 @@ QT_BEGIN_NAMESPACE
 namespace Ui { class MainWindow; }
 QT_END_NAMESPACE
 
-class TCPClient;
-class UpdateController;
-class RecognizeSystem;
-class ExternalExecuter;
-class UpdateNotifyWidget;
-class SettingsWidget;
-class HashComparer;
-class CommonButtonGroupWidget;
-class InstructorButtonGroupWidget;
-class VersionSelectWidget;
-class EntryWidget;
-class ScreenChecker;
 
 class MainWindow : public QMainWindow
 {
@@ -65,11 +53,7 @@ public:
     void showWarning(QString text);
     void setInlineDebug(QString value);
 signals:
-    void sigInitializeClient(MainWindow* mainWindow,
+    void sigInitializeClient(RecognizeSystem *recognize,ExternalExecuter *externalExecuter,SendSystem *sendSystem);
-                             RecognizeSystem *recognizeSystem,
-                             ExternalExecuter *externalExecuter,
-                             SendSystem *sendSystem,
-                             QThread *thread);
     void sigRecognize(UpdateController* updateController,
                       DataParser* dataParser,
                       MainWindow* mainWindow,
@@ -121,6 +105,7 @@ private:
     QTranslator translator;
     TCPClient *client;
     DataParser *dataParser;
+    DataParserOutput *dataParserOutput;
     UpdateController *updateController;
     RecognizeSystem *recognizeSystem;
     ScreenChecker *screenChecker;
@@ -130,6 +115,7 @@ private:
     VersionContainer *versionContainer;
     ResourceManager *resourceManager;
     NotifyController *notifyController;
+    PostProcessorSystem *postProcessorSystem;
 
     QThread *workerThread;
     QThread *animationThread;
@@ -152,6 +138,7 @@ private:
     void showConnectionEmpty();
     void setTitle();
     void setUpUi();
+    void commonWidgetState();
 
     void setServerVersion(StreamingVersionData *version);
     void paintEvent(QPaintEvent *event);