diff --git a/InstructorsAndTrainees/tasks/ammtaskswidget.cpp b/InstructorsAndTrainees/tasks/ammtaskswidget.cpp
index 466e5ac..8ad572d 100644
--- a/InstructorsAndTrainees/tasks/ammtaskswidget.cpp
+++ b/InstructorsAndTrainees/tasks/ammtaskswidget.cpp
@@ -16,7 +16,6 @@ AMMtasksWidget::AMMtasksWidget(ConnectorToServer* connectorToServer, TypeList ty
     loginTraineeSelected(""),
     idTraineeSelected(0),
     threadPreparation(nullptr),
-    threadAnimation(nullptr),
     taskTreePreparation(nullptr),
     waitAnimationWidget(nullptr),
     flOnlyActive(false)
@@ -37,17 +36,14 @@ AMMtasksWidget::AMMtasksWidget(ConnectorToServer* connectorToServer, TypeList ty
     taskTreePreparation->moveToThread(threadPreparation);
     threadPreparation->start();
     threadPreparation->setPriority(QThread::HighestPriority);
-    connect(this, &AMMtasksWidget::signal_prepareListItems, taskTreePreparation, &TaskTreePreparation::slot_prepareListItems);
-    connect(this, &AMMtasksWidget::signal_prepareListItemsForTrainee, taskTreePreparation, &TaskTreePreparation::slot_prepareListItemsForTrainee);
-    connect(taskTreePreparation, &TaskTreePreparation::signal_listItemsReady, this, &AMMtasksWidget::slot_listItemsReady);
+    connect(this, &AMMtasksWidget::signal_prepareAMMListItems, taskTreePreparation, &TaskTreePreparation::slot_prepareAMMListItems);
+    connect(this, &AMMtasksWidget::signal_prepareAMMListItemsForTrainee, taskTreePreparation, &TaskTreePreparation::slot_prepareAMMListItemsForTrainee);
+    connect(taskTreePreparation, &TaskTreePreparation::signal_listAMMItemsReady, this, &AMMtasksWidget::slot_AMMlistItemsReady);
 
-    //threadAnimation = new QThread();
     waitAnimationWidget = new WaitAnimationWidget;    
     QMovie *movie = new QMovie(":/resources/icons/762.gif");
     waitAnimationWidget->setParent(this);
     waitAnimationWidget->initialize(movie,this);
-    //waitAnimationWidget->moveToThread(threadAnimation);
-    //threadAnimation->start();
 
     ui->btnDelete->setObjectName("btnDelete");
     ui->btnDelete->setEnabled(false);
@@ -84,18 +80,15 @@ AMMtasksWidget::~AMMtasksWidget()
     waitAnimationWidget->hideWithStop();
     taskTreePreparation->stopParser();
 
-    //threadAnimation->quit();
-    //threadAnimation->wait();
-
     threadPreparation->quit();
     threadPreparation->wait();
 
-    //delete threadAnimation;
     delete threadPreparation;
 
     delete  taskTreePreparation;
     delete waitAnimationWidget;
     delete  treeWidget;
+
     delete ui;
 }
 
@@ -103,7 +96,6 @@ void AMMtasksWidget::deactivate()
 {
     ui->btnAssignTask->setEnabled(false);
     ui->btnOnlyActive->setEnabled(false);
-    //taskTreePreparation->stopParser();
     treeWidget->clear();
     loginTraineeSelected = "";
     idTraineeSelected = 0;
@@ -116,9 +108,9 @@ void AMMtasksWidget::resizeEvent(QResizeEvent *event)
 
     int width = treeWidget->width();
 
-    treeWidget->setColumnWidth(ColumnsTree::clmn_ID, 50);
-    treeWidget->setColumnWidth(ColumnsTree::clmn_code, 250);
-    treeWidget->setColumnWidth(ColumnsTree::clmn_status, 110);
+    treeWidget->setColumnWidth(ColumnsTreeAMM::clmnAMM_ID, 50);
+    treeWidget->setColumnWidth(ColumnsTreeAMM::clmnAMM_code, 250);
+    treeWidget->setColumnWidth(ColumnsTreeAMM::clmnAMM_status, 110);
 
     int widthPMorDM;
     if(type == TypeList::listCommon)
@@ -126,7 +118,7 @@ void AMMtasksWidget::resizeEvent(QResizeEvent *event)
     else
         widthPMorDM = width - (410 + 10);
 
-    treeWidget->setColumnWidth(ColumnsTree::clmn_PMorDM, widthPMorDM);
+    treeWidget->setColumnWidth(ColumnsTreeAMM::clmnAMM_PMorDM, widthPMorDM);
 }
 
 void AMMtasksWidget::changeEvent(QEvent *event)
@@ -160,7 +152,7 @@ void AMMtasksWidget::on_treeWidget_currentItemChanged(QTreeWidgetItem *current,
         ui->btnDelete->setEnabled(true);
     }
 
-    int id = current->text(ColumnsTree::clmn_ID).toInt();
+    int id = current->text(ColumnsTreeAMM::clmnAMM_ID).toInt();
 
     Module* module = searchModuleByID(id);
 
@@ -213,13 +205,13 @@ void AMMtasksWidget::slot_traineeSelected(QString login)
 
 void AMMtasksWidget::slot_UpdateTasksAMMforTrainee(int trainee_id)
 {
+    qDebug() << "slot_UpdateTasksAMMforTrainee" << QThread::currentThreadId();
     if(type == TypeList::listForTrainee)
     {
         if(idTraineeSelected == trainee_id)
         {
-            //waitAnimationWidget->showWithPlay();
             QList<TaskAmmFim> listTask = connectorToServer->getListTasksAMMforTrainee(trainee_id);
-            signal_prepareListItemsForTrainee(listTask, &listAllModules);
+            signal_prepareAMMListItemsForTrainee(listTask, &listAllModules);
         }
     }
 }
@@ -234,10 +226,10 @@ void AMMtasksWidget::loadTasksAMM(bool flRequestFromDB)
     if(flRequestFromDB)
         /*QByteArray array*/arrayAMM = connectorToServer->getListTaskAmmArray();
 
-    emit signal_prepareListItems(/*array*/arrayAMM, &listAllModules, flOnlyActive);
+    emit signal_prepareAMMListItems(/*array*/arrayAMM, &listAllModules, flOnlyActive);
 }
 
-void AMMtasksWidget::slot_listItemsReady(QList<QTreeWidgetItem *> listItems)
+void AMMtasksWidget::slot_AMMlistItemsReady(QList<QTreeWidgetItem *> listItems)
 {
     //Обновление дерева
     treeWidget->clear();
@@ -270,14 +262,14 @@ Module *AMMtasksWidget::searchModuleByID(int id)
 
 void AMMtasksWidget::preparationTreeWidget()
 {
-    treeWidget->setColumnCount(clmn_count);
+    treeWidget->setColumnCount(clmnAMM_count);
 
     reSetHeadTreeWidget();
 
     if(type == TypeList::listCommon)
     {
-        treeWidget->setColumnHidden(ColumnsTree::clmn_ID, true);
-        treeWidget->setColumnHidden(ColumnsTree::clmn_status, true);
+        treeWidget->setColumnHidden(ColumnsTreeAMM::clmnAMM_ID, true);
+        treeWidget->setColumnHidden(ColumnsTreeAMM::clmnAMM_status, true);
     }
 }
 
@@ -306,7 +298,7 @@ void AMMtasksWidget::assignTaskAMMtoTrainee()
     if(current == nullptr)
         return;
 
-    int id = current->text(ColumnsTree::clmn_ID).toInt();
+    int id = current->text(ColumnsTreeAMM::clmnAMM_ID).toInt();
 
     Module* module = searchModuleByID(id);
 
@@ -341,7 +333,7 @@ void AMMtasksWidget::on_btnDelete_clicked()
         if(treeItemParent == nullptr)
         {//Выбрана задача
 
-            int id = treeItemCurrent->text(ColumnsTree::clmn_ID).toInt();
+            int id = treeItemCurrent->text(ColumnsTreeAMM::clmnAMM_ID).toInt();
 
             if(QMessageBox::warning(this, tr("Attention!"), tr("The deletion will be irrevocable.\nDelete it anyway?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
             {
@@ -351,22 +343,6 @@ void AMMtasksWidget::on_btnDelete_clicked()
     }
 }
 
-void AMMtasksWidget::on_btnOnlyActive_clicked()
-{
-    if(ui->btnOnlyActive->isChecked())
-    {
-        flOnlyActive = true;
-        //slot_listItemsReady(listItemsALL, listItemsACTIVE);
-    }
-    else
-    {
-        flOnlyActive = false;
-        //slot_listItemsReady(listItemsALL, listItemsACTIVE);
-    }
-    //connectorToServer->sendQueryTasksXML("amm");
-    loadTasksAMM(false);
-}
-
 void AMMtasksWidget::on_btnCheck_clicked()
 {
 
@@ -377,3 +353,16 @@ void AMMtasksWidget::on_btnAssignTask_clicked()
     if(QMessageBox::question(this, tr("New task"), tr("Assign this task?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
         assignTaskAMMtoTrainee();
 }
+
+void AMMtasksWidget::on_btnOnlyActive_clicked()
+{
+    if(ui->btnOnlyActive->isChecked())
+    {
+        flOnlyActive = true;
+    }
+    else
+    {
+        flOnlyActive = false;
+    }
+    loadTasksAMM(false);
+}
diff --git a/InstructorsAndTrainees/tasks/ammtaskswidget.h b/InstructorsAndTrainees/tasks/ammtaskswidget.h
index 3606cb5..65beeb8 100644
--- a/InstructorsAndTrainees/tasks/ammtaskswidget.h
+++ b/InstructorsAndTrainees/tasks/ammtaskswidget.h
@@ -39,14 +39,10 @@ protected:
 private Q_SLOTS:
     void on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);
     void on_btnUpdateTasks_clicked();
-
     void on_btnDelete_clicked();
-
-    void on_btnOnlyActive_clicked();
-
     void on_btnCheck_clicked();
-
-    void on_btnAssignTask_clicked();
+    void on_btnAssignTask_clicked();    
+    void on_btnOnlyActive_clicked(); //AMM
 
 
 public Q_SLOTS:
@@ -65,10 +61,10 @@ private:
     void assignTaskAMMtoTrainee();
 
 Q_SIGNALS:
-    void signal_prepareListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive);
-    void signal_prepareListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module*>* listAllModules);
+    void signal_prepareAMMListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive);
+    void signal_prepareAMMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module*>* listAllModules);
 public Q_SLOTS:
-    void slot_listItemsReady(QList<QTreeWidgetItem*> listItems);
+    void slot_AMMlistItemsReady(QList<QTreeWidgetItem*> listItems);
 
 private:
     Ui::AMMtasksWidget *ui;
@@ -82,13 +78,12 @@ private:
     int idTraineeSelected;
 
     QThread* threadPreparation;
-    QThread* threadAnimation;
     TaskTreePreparation* taskTreePreparation;
     WaitAnimationWidget *waitAnimationWidget;
 
-    bool flOnlyActive;
+    bool flOnlyActive; //AMM
 
-    QByteArray arrayAMM;
+    QByteArray arrayAMM; //AMM
 };
 
 #endif // AMMTASKSWIDGET_H
diff --git a/InstructorsAndTrainees/tasks/fimtaskswidget.cpp b/InstructorsAndTrainees/tasks/fimtaskswidget.cpp
index 37e4bba..a1dca3d 100644
--- a/InstructorsAndTrainees/tasks/fimtaskswidget.cpp
+++ b/InstructorsAndTrainees/tasks/fimtaskswidget.cpp
@@ -14,12 +14,13 @@ FIMtasksWidget::FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList ty
     ui(new Ui::FIMtasksWidget),
     connectorToServer(connectorToServer),
     treeWidget(nullptr),
-    type(type),
-    userName(""),
+    type(type),    
     loginTraineeSelected(""),
     idTraineeSelected(0),
-    threadAnimation(nullptr),
-    waitAnimationWidget(nullptr)
+    threadPreparation(nullptr),
+    taskTreePreparation(nullptr),
+    waitAnimationWidget(nullptr),
+    userName("")
 {
     ui->setupUi(this);
 
@@ -27,19 +28,24 @@ FIMtasksWidget::FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList ty
 
     treeWidget = new QTreeWidget();
     ui->horizontalLayout_1->addWidget(treeWidget);
-    //treeWidget->setMinimumSize(400, 400);
 
     connect(treeWidget, &QTreeWidget::currentItemChanged, this, &FIMtasksWidget::on_treeWidget_currentItemChanged);
 
     preparationTreeWidget();
 
-    //threadAnimation = new QThread();
+    threadPreparation = new QThread();
+    taskTreePreparation = new TaskTreePreparation();
+    taskTreePreparation->moveToThread(threadPreparation);
+    threadPreparation->start();
+    threadPreparation->setPriority(QThread::HighestPriority);
+    connect(this, &FIMtasksWidget::signal_prepareFIMListItems, taskTreePreparation, &TaskTreePreparation::slot_prepareFIMListItems);
+    connect(this, &FIMtasksWidget::signal_prepareFIMListItemsForTrainee, taskTreePreparation, &TaskTreePreparation::slot_prepareFIMListItemsForTrainee);
+    connect(taskTreePreparation, &TaskTreePreparation::signal_listFIMItemsReady, this, &FIMtasksWidget::slot_FIMlistItemsReady);
+
     waitAnimationWidget = new WaitAnimationWidget;
     QMovie *movie = new QMovie(":/resources/icons/762.gif");
     waitAnimationWidget->setParent(this);
     waitAnimationWidget->initialize(movie,this);
-    //waitAnimationWidget->moveToThread(threadAnimation);
-    //threadAnimation->start();
 
     ui->btnDelete->setObjectName("btnDelete");
     ui->btnDelete->setEnabled(false);
@@ -62,9 +68,9 @@ FIMtasksWidget::FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList ty
     {
         ui->btnDelete->setVisible(false);
         ui->btnCheck->setVisible(false);
-        this->treeWidget->headerItem()->setHidden(true);
-        this->treeWidget->setSelectionMode(QAbstractItemView::SelectionMode::NoSelection);
         ui->btnAssignTask->setVisible(false);
+        this->treeWidget->headerItem()->setHidden(true);
+        this->treeWidget->setSelectionMode(QAbstractItemView::SelectionMode::NoSelection);        
     }
     else
     {
@@ -76,15 +82,17 @@ FIMtasksWidget::FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList ty
 
 FIMtasksWidget::~FIMtasksWidget()
 {
-    deleteAllTaskAmmFim();
+    //deleteAllTaskAmmFim(); //TODO
 
     waitAnimationWidget->hideWithStop();
+    taskTreePreparation->stopParser();
 
-    //threadAnimation->quit();
-    //threadAnimation->wait();
+    threadPreparation->quit();
+    threadPreparation->wait();
 
-    //delete threadAnimation;
+    delete threadPreparation;
 
+    delete  taskTreePreparation;
     delete waitAnimationWidget;
     delete  treeWidget;
 
@@ -102,7 +110,8 @@ void FIMtasksWidget::deactivate()
 void FIMtasksWidget::setOneTaskFim(TaskAmmFim* task)
 {
     listTaskAmmFim.append(task);
-    fillTree();
+    //fillTree();
+    //TODO
 }
 
 void FIMtasksWidget::resizeEvent(QResizeEvent *event)
@@ -112,8 +121,8 @@ void FIMtasksWidget::resizeEvent(QResizeEvent *event)
 
     int width = treeWidget->width();
 
-    treeWidget->setColumnWidth(ColumnsTree::clmn_ID, 50);
-    treeWidget->setColumnWidth(ColumnsTree::clmn_status, 110);
+    treeWidget->setColumnWidth(ColumnsTreeFIM::clmnFIM_ID, 50);
+    treeWidget->setColumnWidth(ColumnsTreeFIM::clmnFIM_status, 110);
 
     int widthTitle;
     if(type == TypeList::listCommon)
@@ -121,7 +130,7 @@ void FIMtasksWidget::resizeEvent(QResizeEvent *event)
     else
         widthTitle = width - (160 + 10);
 
-    treeWidget->setColumnWidth(ColumnsTree::clmn_Title, widthTitle);
+    treeWidget->setColumnWidth(ColumnsTreeFIM::clmnFIM_Title, widthTitle);
 }
 
 void FIMtasksWidget::changeEvent(QEvent *event)
@@ -139,7 +148,8 @@ void FIMtasksWidget::changeEvent(QEvent *event)
         }
         else if(type == TypeList::listForTrainee)
             if(idTraineeSelected)
-                fillTree();
+                slot_UpdateTasksFIMforTrainee(idTraineeSelected);
+                //fillTree();
     }
 }
 
@@ -157,7 +167,7 @@ void FIMtasksWidget::on_treeWidget_currentItemChanged(QTreeWidgetItem *current,
     QTreeWidgetItem *treeItemParent = current->parent();
     if(treeItemParent == nullptr)
     {//Выбрана задача
-        int id = current->text(ColumnsTree::clmn_ID).toInt();
+        int id = current->text(ColumnsTreeFIM::clmnFIM_ID).toInt();
 
         TaskAmmFim* task = getTaskByID(id);
 
@@ -181,86 +191,7 @@ void FIMtasksWidget::on_treeWidget_currentItemChanged(QTreeWidgetItem *current,
     }
 }
 
-void FIMtasksWidget::loadFIMtasksFromXML(QByteArray array)
-{
-    deleteAllTaskAmmFim();
-
-    QDomDocument docTasksDOM;
-
-    docTasksDOM.setContent(array);
-
-    QDomElement RRJTasksElement = docTasksDOM.firstChildElement("RRJTasks");
-    if(RRJTasksElement.isNull())
-        return;
-
-    QDomElement taskElement = RRJTasksElement.firstChildElement();
-    if(taskElement.isNull())
-        return;
-
-    do
-    {/*task*/
-        QString name = taskElement.nodeName();
-        QDomNamedNodeMap nodeMap = taskElement.attributes();
-
-        if(name == "task")
-        {
-            TaskAmmFim* task = nullptr;
-            task = new TaskAmmFim();
-
-            task->initialize(/*nodeMap.namedItem("id").nodeValue().toInt()*/ TaskAmmFim::lastID++,
-                             nodeMap.namedItem("type").nodeValue(),
-                             nodeMap.namedItem("title").nodeValue(),
-                             nodeMap.namedItem("status").nodeValue(),
-                             nodeMap.namedItem("created").nodeValue(),
-                             nodeMap.namedItem("changed").nodeValue());
-
-            QDomElement malfunctionElement = taskElement.firstChildElement();
-            if(!malfunctionElement.isNull())
-            {
-                do
-                {/*malfunction*/
-                    QString name = malfunctionElement.nodeName();
-                    QDomNamedNodeMap nodeMap = malfunctionElement.attributes();
-
-                    if(name == "malfunction")
-                    {
-                        Malfunction malfunction;
-
-                        malfunction.initialize(nodeMap.namedItem("dmCode").nodeValue(),
-                                               nodeMap.namedItem("num").nodeValue(),
-                                               nodeMap.namedItem("description").nodeValue());
-
-                        QDomElement signElement = malfunctionElement.firstChildElement();
-                        if(!signElement.isNull())
-                        {
-                            do
-                            {/*malfunctionSign*/
-                                QString name = signElement.nodeName();
-                                QDomNamedNodeMap nodeMap = signElement.attributes();
-
-                                if(name == "malfunctionSign")
-                                {
-                                    MalfunctionSign sign;
-
-                                    sign.initialize(nodeMap.namedItem("type").nodeValue().toInt(),
-                                                    nodeMap.namedItem("description").nodeValue());
-
-                                    malfunction.addMalfunctionSign(sign);
-                                }
-
-                            }while(! (signElement = signElement.nextSiblingElement()).isNull());
-                        }
-                        task->addMalfunction(malfunction);
-                    }
-                }while(! (malfunctionElement = malfunctionElement.nextSiblingElement()).isNull());
-            }
-            listTaskAmmFim.append(task);
-        }
-    }while (! (taskElement = taskElement.nextSiblingElement()).isNull());
-
-    return;
-}
-
+#ifdef OLD_FILL
 void FIMtasksWidget::fillTree()
 {
     //Обновление дерева
@@ -351,6 +282,7 @@ void FIMtasksWidget::fillTree()
     }
 }
 
+/*
 void FIMtasksWidget::prepareListTasksForTrainee(QList<TaskAmmFim> listTask)
 {
     deleteAllTaskAmmFim();
@@ -363,31 +295,9 @@ void FIMtasksWidget::prepareListTasksForTrainee(QList<TaskAmmFim> listTask)
         listTaskAmmFim.append(newTask);
     }
 }
+*/
+#endif
 
-void FIMtasksWidget::preparationTreeWidget()
-{
-    treeWidget->setColumnCount(clmn_count);
-
-    reSetHeadTreeWidget();
-
-    if(type == TypeList::listCommon || type == TypeList::listOneTask)
-    {
-        treeWidget->setColumnHidden(ColumnsTree::clmn_ID, true);
-        treeWidget->setColumnHidden(ColumnsTree::clmn_status, true);
-    }
-}
-
-void FIMtasksWidget::reSetHeadTreeWidget()
-{
-    QStringList listHeaders;
-
-    if(type == TypeList::listForTrainee)
-        listHeaders = QStringList{tr("Task FIM"), tr("ID"), tr("Status")};
-    else
-        listHeaders = QStringList{tr("Title"), tr("ID"), tr("Status")};
-
-    treeWidget->setHeaderLabels(listHeaders);
-}
 
 void FIMtasksWidget::slot_NeedUpdateUI()
 {
@@ -410,15 +320,16 @@ void FIMtasksWidget::slot_traineeSelected(QString login)
 
 void FIMtasksWidget::slot_UpdateTasksFIMforTrainee(int trainee_id)
 {
-    qDebug() << "SlotUpdateTasksUI" << QThread::currentThreadId();
+    qDebug() << "slot_UpdateTasksFIMforTrainee" << QThread::currentThreadId();
     if(type == TypeList::listForTrainee)
     {
         if(idTraineeSelected == trainee_id)
         {
             QList<TaskAmmFim> listTask = connectorToServer->getListTasksFIMforTrainee(trainee_id);
-            prepareListTasksForTrainee(listTask);
-            fillTree();
-            waitAnimationWidget->hideWithStop();
+            emit signal_prepareFIMListItemsForTrainee(listTask, &listTaskAmmFim);
+            //prepareListTasksForTrainee(listTask);
+            //fillTree();
+            //waitAnimationWidget->hideWithStop();
         }
     }
 }
@@ -430,11 +341,27 @@ void FIMtasksWidget::loadTasksFIM()
 
     waitAnimationWidget->showWithPlay();
 
-    QByteArray array = connectorToServer->getListTaskFimArray();
-    loadFIMtasksFromXML(array);
+    QByteArray arrayFIM = connectorToServer->getListTaskFimArray();
 
+    //loadFIMtasksFromXML(arrayFIM);
     //собственно обновление дерева
-    fillTree();
+    //fillTree();
+    //waitAnimationWidget->hideWithStop();
+
+    emit signal_prepareFIMListItems(arrayFIM, &listTaskAmmFim);
+}
+
+void FIMtasksWidget::slot_FIMlistItemsReady(QList<QTreeWidgetItem *> listItems)
+{
+    //Обновление дерева
+    treeWidget->clear();
+
+    for(QTreeWidgetItem * item : listItems)
+        treeWidget->addTopLevelItem(item);
+
+    QTreeWidgetItem * item = treeWidget->topLevelItem(0);
+    if(item != nullptr)
+        treeWidget->setCurrentItem(item);
 
     waitAnimationWidget->hideWithStop();
 }
@@ -451,26 +378,29 @@ TaskAmmFim* FIMtasksWidget::getTaskByID(int id)
     return nullptr;
 }
 
-void FIMtasksWidget::deleteAllTaskAmmFim()
+void FIMtasksWidget::preparationTreeWidget()
 {
-    if(type == TypeList::listOneTask)
-        return;
+    treeWidget->setColumnCount(clmnFIM_count);
 
-    for(TaskAmmFim* task: listTaskAmmFim)
-        delete task;
+    reSetHeadTreeWidget();
 
-    listTaskAmmFim.clear();
+    if(type == TypeList::listCommon || type == TypeList::listOneTask)
+    {
+        treeWidget->setColumnHidden(ColumnsTreeFIM::clmnFIM_ID, true);
+        treeWidget->setColumnHidden(ColumnsTreeFIM::clmnFIM_status, true);
+    }
 }
 
-void FIMtasksWidget::updateTaskItem(QTreeWidgetItem *itemTask)
+void FIMtasksWidget::reSetHeadTreeWidget()
 {
-    for (int i = 0; i < itemTask->childCount(); i++)
-    {
-        QTreeWidgetItem* itemMalfunction = itemTask->child(i);
-        itemMalfunction->setCheckState(0, Qt::Checked);
-        itemMalfunction->setExpanded(false);
-    }
-    itemTask->setExpanded(false);
+    QStringList listHeaders;
+
+    if(type == TypeList::listForTrainee)
+        listHeaders = QStringList{tr("Task FIM"), tr("ID"), tr("Status")};
+    else
+        listHeaders = QStringList{tr("Title"), tr("ID"), tr("Status")};
+
+    treeWidget->setHeaderLabels(listHeaders);
 }
 
 void FIMtasksWidget::on_btnUpdateTasks_clicked()
@@ -485,7 +415,7 @@ void FIMtasksWidget::assignTaskFIMtoTrainee()
     if(current == nullptr)
         return;
 
-    int id = current->text(ColumnsTree::clmn_ID).toInt();
+    int id = current->text(ColumnsTreeFIM::clmnFIM_ID).toInt();
 
     TaskAmmFim* task = getTaskByID(id);
 
@@ -510,7 +440,7 @@ void FIMtasksWidget::assignTaskFIMtoTrainee()
 
         connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_FIM_TO_TRAINEE, trainee_id, &taskNew);
 
-        updateTaskItem(current);
+        updateTaskItem(current); //TODO ?
     }
 }
 
@@ -524,7 +454,7 @@ void FIMtasksWidget::on_btnDelete_clicked()
         if(treeItemParent == nullptr)
         {//Выбрана задача
 
-            int id = treeItemCurrent->text(ColumnsTree::clmn_ID).toInt();
+            int id = treeItemCurrent->text(ColumnsTreeFIM::clmnFIM_ID).toInt();
 
             if(QMessageBox::warning(this, tr("Attention!"), tr("The deletion will be irrevocable.\nDelete it anyway?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
             {
@@ -544,7 +474,7 @@ void FIMtasksWidget::on_btnCheck_clicked()
         if(treeItemParent == nullptr)
         {//Выбрана задача
 
-            int id = treeItemCurrent->text(ColumnsTree::clmn_ID).toInt();
+            int id = treeItemCurrent->text(ColumnsTreeFIM::clmnFIM_ID).toInt();
 
             TaskAmmFim* task = getTaskByID(id);
 
@@ -568,3 +498,16 @@ void FIMtasksWidget::on_btnAssignTask_clicked()
     if(QMessageBox::question(this, tr("New task"), tr("Assign this task?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
         assignTaskFIMtoTrainee();
 }
+
+void FIMtasksWidget::updateTaskItem(QTreeWidgetItem *itemTask)
+{
+    for (int i = 0; i < itemTask->childCount(); i++)
+    {
+        QTreeWidgetItem* itemMalfunction = itemTask->child(i);
+        itemMalfunction->setCheckState(0, Qt::Checked);
+        itemMalfunction->setExpanded(false);
+    }
+    itemTask->setExpanded(false);
+}
+
+
diff --git a/InstructorsAndTrainees/tasks/fimtaskswidget.h b/InstructorsAndTrainees/tasks/fimtaskswidget.h
index 3251cd0..33798d1 100644
--- a/InstructorsAndTrainees/tasks/fimtaskswidget.h
+++ b/InstructorsAndTrainees/tasks/fimtaskswidget.h
@@ -5,6 +5,7 @@
 #include <QTreeWidget>
 #include "tasksAmmFim.h"
 #include "connectortoserver.h"
+#include "taskTreePreparation.h"
 
 namespace Ui {
 class FIMtasksWidget;
@@ -23,12 +24,7 @@ public:
     };
 
 private:
-    enum ColumnsTree{
-        clmn_Title = 0,
-        clmn_ID,
-        clmn_status,
-        clmn_count
-    };
+
 
 public:
     explicit FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList type, QWidget *parent = nullptr);
@@ -36,8 +32,7 @@ public:
 
 public:
     void deactivate();
-
-    void setOneTaskFim(TaskAmmFim* task);
+    void setOneTaskFim(TaskAmmFim* task); //FIM
 
 public:
     void resizeEvent(QResizeEvent *event) override;
@@ -47,11 +42,8 @@ protected:
 private Q_SLOTS:
     void on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);
     void on_btnUpdateTasks_clicked();
-
     void on_btnDelete_clicked();
-
     void on_btnCheck_clicked();
-
     void on_btnAssignTask_clicked();
 
 public Q_SLOTS:
@@ -64,20 +56,26 @@ public Q_SLOTS:
 
 private:
     TaskAmmFim* getTaskByID(int id);
-    void loadFIMtasksFromXML(QByteArray array);
-    void fillTree();
-
-    void prepareListTasksForTrainee(QList<TaskAmmFim> listTask);
-
     void preparationTreeWidget();
     void reSetHeadTreeWidget();
     void loadTasksFIM();
+    void assignTaskFIMtoTrainee();
 
-    void deleteAllTaskAmmFim();
+
+    /*
+    void fillTree();
+    void prepareListTasksForTrainee(QList<TaskAmmFim> listTask);
+    */
 
     void updateTaskItem(QTreeWidgetItem *itemTask);
 
-    void assignTaskFIMtoTrainee();
+
+
+Q_SIGNALS:
+    void signal_prepareFIMListItems(QByteArray array, QList<TaskAmmFim*>* listTaskAmmFim);
+    void signal_prepareFIMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<TaskAmmFim*>* listTaskAmmFim);
+public Q_SLOTS:
+    void slot_FIMlistItemsReady(QList<QTreeWidgetItem*> listItems);
 
 private:
     Ui::FIMtasksWidget *ui;
@@ -85,14 +83,16 @@ private:
     QTreeWidget* treeWidget;
     TypeList type;
 
-private:
-    QString userName;
+private:    
     QList<TaskAmmFim*> listTaskAmmFim;
     QString loginTraineeSelected;
     int idTraineeSelected;
 
-    QThread* threadAnimation;
+    QThread* threadPreparation;
+    TaskTreePreparation* taskTreePreparation;
     WaitAnimationWidget *waitAnimationWidget;
+
+    QString userName; //FIM
 };
 
 #endif // FIMTASKSWIDGET_H
diff --git a/InstructorsAndTrainees/tasks/tasktreepreparation.cpp b/InstructorsAndTrainees/tasks/tasktreepreparation.cpp
index 41c4da9..524bf90 100644
--- a/InstructorsAndTrainees/tasks/tasktreepreparation.cpp
+++ b/InstructorsAndTrainees/tasks/tasktreepreparation.cpp
@@ -5,7 +5,8 @@
 
 TaskTreePreparation::TaskTreePreparation(QObject *parent) :
     QObject(parent),
-    listAllModules(nullptr),
+    listAllModulesAMM(nullptr),
+    listTaskAmmFim(nullptr),
     flagStop(false)
 {
     qDebug() << "TaskTreePreparation init thread ID " << QThread::currentThreadId();
@@ -13,7 +14,7 @@ TaskTreePreparation::TaskTreePreparation(QObject *parent) :
 
 TaskTreePreparation::~TaskTreePreparation()
 {
-    deleteAllModuls();
+    deleteAllModulsAMM();
 }
 
 void TaskTreePreparation::stopParser()
@@ -21,7 +22,7 @@ void TaskTreePreparation::stopParser()
     flagStop = true;
 }
 
-QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool flOnlyActive, QTreeWidgetItem *parentItem)
+QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidgetAMM(Module *module, bool flOnlyActive, QTreeWidgetItem *parentItem)
 {
     QTreeWidgetItem* itemModule = nullptr;
 
@@ -48,7 +49,7 @@ QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool
 
         for(Module* module : PMmodul->getListChildModules())
         {
-            addModuleToTreeWidget(module, flOnlyActive, itemModule);
+            addModuleToTreeWidgetAMM(module, flOnlyActive, itemModule);
         }
     }
     else
@@ -62,9 +63,9 @@ QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool
         itemModule->setIcon(0, QIcon(":/resources/icons/procedure.png"));
     }
 
-    itemModule->setText(ColumnsTree::clmn_PMorDM, text);
-    itemModule->setText(ColumnsTree::clmn_code, code);
-    itemModule->setText(ColumnsTree::clmn_ID, ID);
+    itemModule->setText(ColumnsTreeAMM::clmnAMM_PMorDM, text);
+    itemModule->setText(ColumnsTreeAMM::clmnAMM_code, code);
+    itemModule->setText(ColumnsTreeAMM::clmnAMM_ID, ID);
     itemModule->setToolTip(0, text);
 
     return itemModule;
@@ -72,7 +73,7 @@ QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool
 
 void TaskTreePreparation::loadAMMtasksFromXML(QByteArray array)
 {
-    deleteAllModuls();
+    deleteAllModulsAMM();
 
     QDomDocument docTasksDOM;
 
@@ -82,25 +83,117 @@ void TaskTreePreparation::loadAMMtasksFromXML(QByteArray array)
     if(manifestElement.isNull())
         return;
 
-    domElementParser(manifestElement, nullptr);
+    domElementParserAMM(manifestElement, nullptr);
 }
 
-void TaskTreePreparation::deleteAllModuls()
+void TaskTreePreparation::loadFIMtasksFromXML(QByteArray array)
 {
-    if(listAllModules == nullptr)
+    deleteAllTaskAmmFim();
+
+    QDomDocument docTasksDOM;
+
+    docTasksDOM.setContent(array);
+
+    QDomElement RRJTasksElement = docTasksDOM.firstChildElement("RRJTasks");
+    if(RRJTasksElement.isNull())
         return;
 
-    for(Module* module: *listAllModules)
+    QDomElement taskElement = RRJTasksElement.firstChildElement();
+    if(taskElement.isNull())
+        return;
+
+    do
+    {/*task*/
+        QString name = taskElement.nodeName();
+        QDomNamedNodeMap nodeMap = taskElement.attributes();
+
+        if(name == "task")
+        {
+            TaskAmmFim* task = nullptr;
+            task = new TaskAmmFim();
+
+            task->initialize(/*nodeMap.namedItem("id").nodeValue().toInt()*/ TaskAmmFim::lastID++,
+                             nodeMap.namedItem("type").nodeValue(),
+                             nodeMap.namedItem("title").nodeValue(),
+                             nodeMap.namedItem("status").nodeValue(),
+                             nodeMap.namedItem("created").nodeValue(),
+                             nodeMap.namedItem("changed").nodeValue());
+
+            QDomElement malfunctionElement = taskElement.firstChildElement();
+            if(!malfunctionElement.isNull())
+            {
+                do
+                {/*malfunction*/
+                    QString name = malfunctionElement.nodeName();
+                    QDomNamedNodeMap nodeMap = malfunctionElement.attributes();
+
+                    if(name == "malfunction")
+                    {
+                        Malfunction malfunction;
+
+                        malfunction.initialize(nodeMap.namedItem("dmCode").nodeValue(),
+                                               nodeMap.namedItem("num").nodeValue(),
+                                               nodeMap.namedItem("description").nodeValue());
+
+                        QDomElement signElement = malfunctionElement.firstChildElement();
+                        if(!signElement.isNull())
+                        {
+                            do
+                            {/*malfunctionSign*/
+                                QString name = signElement.nodeName();
+                                QDomNamedNodeMap nodeMap = signElement.attributes();
+
+                                if(name == "malfunctionSign")
+                                {
+                                    MalfunctionSign sign;
+
+                                    sign.initialize(nodeMap.namedItem("type").nodeValue().toInt(),
+                                                    nodeMap.namedItem("description").nodeValue());
+
+                                    malfunction.addMalfunctionSign(sign);
+                                }
+
+                            }while(! (signElement = signElement.nextSiblingElement()).isNull());
+                        }
+                        task->addMalfunction(malfunction);
+                    }
+                }while(! (malfunctionElement = malfunctionElement.nextSiblingElement()).isNull());
+            }
+            listTaskAmmFim->append(task);
+        }
+    }while (! (taskElement = taskElement.nextSiblingElement()).isNull());
+
+    return;
+}
+
+void TaskTreePreparation::deleteAllTaskAmmFim()
+{
+    //if(type == TypeList::listOneTask)
+        //return;
+
+    for(TaskAmmFim* task: *listTaskAmmFim)
+        delete task;
+
+    listTaskAmmFim->clear();
+}
+
+
+void TaskTreePreparation::deleteAllModulsAMM()
+{
+    if(listAllModulesAMM == nullptr)
+        return;
+
+    for(Module* module: *listAllModulesAMM)
     {
         if(module->getType() == ModuleType::TYPE_PM)
             delete static_cast<PM*>(module);
         else
             delete static_cast<DM*>(module);
     }
-    listAllModules->clear();
+    listAllModulesAMM->clear();
 }
 
-void TaskTreePreparation::domElementParser(QDomElement element, Module* moduleParent)
+void TaskTreePreparation::domElementParserAMM(QDomElement element, Module* moduleParent)
 {
     QString name;
 
@@ -200,38 +293,39 @@ void TaskTreePreparation::domElementParser(QDomElement element, Module* modulePa
 
        }
 
-        domElementParser(childElement, module);
+        domElementParserAMM(childElement, module);
 
         if(moduleParent == nullptr)
-            listAllModules->append(module);
+            listAllModulesAMM->append(module);
 
     }while (! (childElement = childElement.nextSiblingElement()).isNull());
 }
 
-void TaskTreePreparation::slot_prepareListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive)
-{
-    qDebug() << "TaskTreePreparation::slot_prepareListItems thread ID " << QThread::currentThreadId();
 
-    this->listAllModules = listAllModules;
+void TaskTreePreparation::slot_prepareAMMListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive)
+{
+    qDebug() << "TaskTreePreparation::slot_prepareAMMListItems thread ID " << QThread::currentThreadId();
+
+    this->listAllModulesAMM = listAllModules;
 
     loadAMMtasksFromXML(array);
 
     listItems.clear();
 
-    for(Module* module : *this->listAllModules)
+    for(Module* module : *this->listAllModulesAMM)
     {
-        QTreeWidgetItem*  item = addModuleToTreeWidget(module, flOnlyActive);
+        QTreeWidgetItem*  item = addModuleToTreeWidgetAMM(module, flOnlyActive);
         listItems.append(item);
     }
 
-    Q_EMIT signal_listItemsReady(listItems);
+    Q_EMIT signal_listAMMItemsReady(listItems);
 }
 
-void TaskTreePreparation::slot_prepareListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module *> *listAllModules)
+void TaskTreePreparation::slot_prepareAMMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module *> *listAllModules)
 {
-    qDebug() << "TaskTreePreparation::slot_prepareListItemsForTrainee thread ID " << QThread::currentThreadId();
+    qDebug() << "TaskTreePreparation::slot_prepareAMMListItemsForTrainee thread ID " << QThread::currentThreadId();
 
-    this->listAllModules = listAllModules;
+    this->listAllModulesAMM = listAllModules;
 
     //loadAMMtasksFromList(listTask);
 
@@ -249,29 +343,29 @@ void TaskTreePreparation::slot_prepareListItemsForTrainee(QList<TaskAmmFim> list
         item = new QTreeWidgetItem();
         item->setIcon(0, QIcon(":/resources/icons/procedure.png"));
 
-        item->setText(ColumnsTree::clmn_PMorDM, text);
-        item->setText(ColumnsTree::clmn_code, code);
-        item->setText(ColumnsTree::clmn_ID, ID);        
+        item->setText(ColumnsTreeAMM::clmnAMM_PMorDM, text);
+        item->setText(ColumnsTreeAMM::clmnAMM_code, code);
+        item->setText(ColumnsTreeAMM::clmnAMM_ID, ID);
 
         if(status == "completed")
         {
-            item->setText(ColumnsTree::clmn_status, tr("completed"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("completed"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
         }
         else if(status == "failed")
         {
-            item->setText(ColumnsTree::clmn_status, tr("failed"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("failed"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
         }
         else if(status == "checkup")
         {
-            item->setText(ColumnsTree::clmn_status, tr("checkup"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("checkup"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
         }
         else
         {
-            item->setText(ColumnsTree::clmn_status, tr("new"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("new"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
         }
 
         item->setToolTip(0, text);
@@ -279,5 +373,182 @@ void TaskTreePreparation::slot_prepareListItemsForTrainee(QList<TaskAmmFim> list
         listItems.append(item);
     }
 
-    Q_EMIT signal_listItemsReady(listItems);
+    Q_EMIT signal_listAMMItemsReady(listItems);
+}
+
+void TaskTreePreparation::slot_prepareFIMListItems(QByteArray array, QList<TaskAmmFim *> *listTaskAmmFim)
+{
+    qDebug() << "TaskTreePreparation::slot_prepareFIMListItems thread ID " << QThread::currentThreadId();
+
+    this->listTaskAmmFim = listTaskAmmFim;
+
+    loadFIMtasksFromXML(array);
+
+    listItems.clear();
+
+    for(TaskAmmFim* taskPtr : *this->listTaskAmmFim)
+        {/*Задачи*/
+            TaskAmmFim task = *taskPtr;
+
+            QTreeWidgetItem* itemTask = new QTreeWidgetItem();
+
+            itemTask->setText(0, task.title);
+            itemTask->setText(1, QString::number(task.id));
+            //itemTask->setFlags(itemTask->flags() | Qt::ItemIsUserCheckable);
+            //itemTask->setCheckState(0, Qt::Checked);
+
+            if(task.status == "completed")
+            {
+                itemTask->setText(2, tr("completed"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
+            }
+            else if(task.status == "failed")
+            {
+                itemTask->setText(2, tr("failed"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
+            }
+            else if(task.status == "checkup")
+            {
+                itemTask->setText(2, tr("checkup"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
+            }
+            else
+            {
+                itemTask->setText(2, tr("new"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
+            }
+
+
+            itemTask->setIcon(0, QIcon(":/resources/icons/procedure.png"));
+            itemTask->setToolTip(0, task.title);
+
+            //treeWidget->addTopLevelItem(itemTask);
+
+            for (int j = 0; j < task.malfunctionList.count(); j++)
+            {/*Неисправности*/
+                Malfunction malfunction = task.malfunctionList.at(j);
+
+                QTreeWidgetItem* itemMalfunction = new QTreeWidgetItem();
+
+                itemMalfunction->setText(0, malfunction.description);
+                //if(type == TypeList::listCommon) //TODO
+                {
+                    itemMalfunction->setFlags(itemMalfunction->flags() | Qt::ItemIsUserCheckable);
+                    itemMalfunction->setCheckState(0, Qt::Checked);
+                }
+
+                itemMalfunction->setIcon(0, QIcon(":/resources/icons/malfunction.png"));
+                itemMalfunction->setToolTip(0, malfunction.description);
+
+                itemTask->addChild(itemMalfunction);
+
+                for (int k = 0; k < malfunction.malfunctionSigns.count(); k++)
+                {/*Сигнализация*/
+                    MalfunctionSign sign = malfunction.malfunctionSigns.at(k);
+
+                    QTreeWidgetItem* itemSign = new QTreeWidgetItem();
+
+                    itemSign->setText(0, sign.description);
+                    //itemSign->setFlags(itemSign->flags() | Qt::ItemIsUserCheckable);
+                    //itemSign->setCheckState(0, Qt::Checked);
+                    itemSign->setIcon(0, QIcon(":/resources/icons/sign.png"));
+                    itemSign->setToolTip(0, sign.description);
+
+                    itemMalfunction->addChild(itemSign);
+                }
+            }
+            listItems.append(itemTask);
+        }
+
+    Q_EMIT signal_listFIMItemsReady(listItems);
+}
+
+void TaskTreePreparation::slot_prepareFIMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<TaskAmmFim *> *listTaskAmmFim)
+{
+    qDebug() << "TaskTreePreparation::slot_prepareFIMListItemsForTrainee thread ID " << QThread::currentThreadId();
+
+    this->listTaskAmmFim = listTaskAmmFim;
+
+    listItems.clear();
+
+    for(TaskAmmFim task : listTask)
+    {/*Задачи*/
+        //TaskAmmFim* task = listTaskAmmFim.at(i);
+        TaskAmmFim* taskNew = nullptr;
+        taskNew = new TaskAmmFim();
+        *taskNew = task;
+        this->listTaskAmmFim->append(taskNew);
+
+        QTreeWidgetItem* itemTask = new QTreeWidgetItem();
+
+        itemTask->setText(0, task.title);
+        itemTask->setText(1, QString::number(task.id));
+        //itemTask->setFlags(itemTask->flags() | Qt::ItemIsUserCheckable);
+        //itemTask->setCheckState(0, Qt::Checked);
+
+        if(task.status == "completed")
+        {
+            itemTask->setText(2, tr("completed"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
+        }
+        else if(task.status == "failed")
+        {
+            itemTask->setText(2, tr("failed"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
+        }
+        else if(task.status == "checkup")
+        {
+            itemTask->setText(2, tr("checkup"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
+        }
+        else
+        {
+            itemTask->setText(2, tr("new"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
+        }
+
+
+        itemTask->setIcon(0, QIcon(":/resources/icons/procedure.png"));
+        itemTask->setToolTip(0, task.title);
+
+        //treeWidget->addTopLevelItem(itemTask);
+
+        for (int j = 0; j < task.malfunctionList.count(); j++)
+        {/*Неисправности*/
+            Malfunction malfunction = task.malfunctionList.at(j);
+
+            QTreeWidgetItem* itemMalfunction = new QTreeWidgetItem();
+
+            itemMalfunction->setText(0, malfunction.description);
+            //if(type == TypeList::listCommon) //TODO
+            {
+                itemMalfunction->setFlags(itemMalfunction->flags() | Qt::ItemIsUserCheckable);
+                itemMalfunction->setCheckState(0, Qt::Checked);
+            }
+
+            itemMalfunction->setIcon(0, QIcon(":/resources/icons/malfunction.png"));
+            itemMalfunction->setToolTip(0, malfunction.description);
+
+            itemTask->addChild(itemMalfunction);
+
+            for (int k = 0; k < malfunction.malfunctionSigns.count(); k++)
+            {/*Сигнализация*/
+                MalfunctionSign sign = malfunction.malfunctionSigns.at(k);
+
+                QTreeWidgetItem* itemSign = new QTreeWidgetItem();
+
+                itemSign->setText(0, sign.description);
+                //itemSign->setFlags(itemSign->flags() | Qt::ItemIsUserCheckable);
+                //itemSign->setCheckState(0, Qt::Checked);
+                itemSign->setIcon(0, QIcon(":/resources/icons/sign.png"));
+                itemSign->setToolTip(0, sign.description);
+
+                itemMalfunction->addChild(itemSign);
+            }
+        }
+
+        listItems.append(itemTask);
+    }
+
+    Q_EMIT signal_listFIMItemsReady(listItems);
 }
diff --git a/InstructorsAndTrainees/tasks/tasktreepreparation.h b/InstructorsAndTrainees/tasks/tasktreepreparation.h
index c7dc7c2..41f43a1 100644
--- a/InstructorsAndTrainees/tasks/tasktreepreparation.h
+++ b/InstructorsAndTrainees/tasks/tasktreepreparation.h
@@ -7,14 +7,22 @@
 #include "module.h"
 #include "tasksAmmFim.h"
 
-enum ColumnsTree{
-    clmn_PMorDM = 0,
-    clmn_code,
-    clmn_ID,
-    clmn_status,
-    clmn_count
+enum ColumnsTreeAMM{
+    clmnAMM_PMorDM = 0,
+    clmnAMM_code,
+    clmnAMM_ID,
+    clmnAMM_status,
+    clmnAMM_count
 };
 
+enum ColumnsTreeFIM{
+    clmnFIM_Title = 0,
+    clmnFIM_ID,
+    clmnFIM_status,
+    clmnFIM_count
+};
+
+
 class TaskTreePreparation : public QObject
 {
     Q_OBJECT
@@ -26,21 +34,32 @@ public:
     void stopParser();
 
 private:
-    QTreeWidgetItem* addModuleToTreeWidget(Module* module, bool flOnlyActive = false, QTreeWidgetItem* parentItem = nullptr);
+    QTreeWidgetItem* addModuleToTreeWidgetAMM(Module* module, bool flOnlyActive = false, QTreeWidgetItem* parentItem = nullptr);
     void loadAMMtasksFromXML(QByteArray array);
-    void domElementParser(QDomElement element, Module* moduleParent);
-    void deleteAllModuls();
+    void domElementParserAMM(QDomElement element, Module* moduleParent);
+    void deleteAllModulsAMM();
+
+    void loadFIMtasksFromXML(QByteArray array);
+    void deleteAllTaskAmmFim();
 
 public Q_SLOTS:
-    void slot_prepareListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive);
-    void slot_prepareListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module*>* listAllModules);
+    void slot_prepareAMMListItems(QByteArray array, QList<Module*>* listAllModulesAMM, bool flOnlyActive);
+    void slot_prepareAMMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module*>* listAllModulesAMM);
+
+    void slot_prepareFIMListItems(QByteArray array, QList<TaskAmmFim*>* listTaskAmmFim);
+    void slot_prepareFIMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<TaskAmmFim*>* listTaskAmmFim);
 
 Q_SIGNALS:
-    void signal_listItemsReady(QList<QTreeWidgetItem*> listItems);
+    void signal_listAMMItemsReady(QList<QTreeWidgetItem*> listItemsAMM);
+
+    void signal_listFIMItemsReady(QList<QTreeWidgetItem*> listItemsFIM);
 
 private:
     QList<QTreeWidgetItem*> listItems;
-    QList<Module*>* listAllModules;
+
+    QList<Module*>* listAllModulesAMM;
+    QList<TaskAmmFim*>* listTaskAmmFim;
+
     bool flagStop;
 };