#include "createstepdialog.h"
#include "ui_createstepdialog.h"

#include "model/step/tools.h"
#include "model/actioncreator.h"
#include "model/step/parameters/abstractparameter.h"
#include "model/step/parameters/parameterbool.h"
#include "model/step/parameters/parameterdouble.h"
#include "model/step/parameters/parameteremptyline.h"
#include "model/step/parameters/parameterexcludevalue.h"
#include "model/step/parameters/parameterfilechoice.h"
#include "model/step/parameters/parameterint.h"
#include "model/step/parameters/parameterstring.h"
#include "model/step/parameters/parameterstringchoice.h"
#include "model/step/parameters/parametertextline.h"
#include "model/step/models/abstractinmodel.h"
#include "model/step/models/inresultmodel.h"
#include "model/step/models/ingroupmodel.h"
#include "model/step/models/initemmodel.h"
#include "model/step/models/abstractoutmodel.h"
#include "model/step/models/outresultmodel.h"
#include "model/step/models/outgroupmodel.h"
#include "model/step/models/outitemmodel.h"
#include "view/step/models/outresultwidget.h"

#include <QRegExpValidator>
#include <QMessageBox>

CreateStepDialog::CreateStepDialog(QString directory,
                                   QString code,
                                   QWidget *parent) : QDialog(parent)
{
    ui = new Ui::CreateStepDialog;
    ui->setupUi(this);

    ui->lb_begin->setText(QString("%1_StepNom").arg(code.toUpper()));
    ui->le_name->setText("");

    QRegExp re("([A-Za-z]+)");
    QRegExpValidator *validator = new QRegExpValidator(re, this);
    ui->le_name->setValidator(validator);

    _logMessage      = "";
    _pluginDirectory = directory;
    _pluginCode      = code;

    connect(ui->le_name           , SIGNAL(textChanged    (const QString)),
            this                  , SLOT  (fullNameChanged(const QString)));
    connect(ui->tabWidget         , SIGNAL(currentChanged(int)),
            this                  , SLOT  (tabChanged    (int)));
    connect(ui->rb_canbeaddedfirst, SIGNAL(toggled     (bool)),
            this                  , SLOT  (setFirstStep(bool)));

    // Tab 2
    _parameterCreator = new ParametersCreator();
    _modelParameter = _parameterCreator->getStandardItemModel();
    ui->treeView_2->setModel(_modelParameter);
    _layoutParameter = new QVBoxLayout();
    ui->widgetZone_2->setLayout(_layoutParameter);
    _activeWidgetParameter = NULL;

    // Tab 3
    _inModelCreator = new InModelCreator();
    _modelIN = _inModelCreator->getStandardItemModel();
    ui->treeView_3->setModel(_modelIN);
    _layoutIN = new QVBoxLayout();
    ui->widgetZone_3->setLayout(_layoutIN);
    _activeWidgetIN = NULL;

    // Tab 4
    _outModelCreator = new OutModelCreator(_inModelCreator->getStandardItemModel());
    _modelOUT = _outModelCreator->getStandardItemModel();
    ui->treeView_5->setModel(_modelOUT);
    _layoutOUT = new QVBoxLayout();
    ui->widgetZone_5->setLayout(_layoutOUT);
    _activeWidgetOUT = NULL;

    _modelINmodified  = false;
    _modelOUTmodified = false;
}

CreateStepDialog::~CreateStepDialog()
{
    delete _parameterCreator;
    delete _inModelCreator;
    delete _outModelCreator;

    delete ui;
}

void CreateStepDialog::accept()
{
    bool ok1 = checkInformation();
    bool ok2 = checkParameters               (_modelParameter, tr("paramètres"  ));
    bool ok3 = checkModels<AbstractInModel  >(_modelIN       , tr("modèles IN"  ));
    bool ok4 = checkModels<AbstractOutModel >(_modelOUT      , tr("modèles OUT" ));

    if (ok1 && ok2 && ok3 && ok4)
    {
        StepCreator creator(_pluginDirectory,ui->le_name->text(),_pluginCode);
        creator.setInformation(ui->le_description->text(),
                               ui->te_detailledDescription->toPlainText(),
                               ui->rb_canbeaddedfirst->isChecked(),
                               ui->cb_actionStep->isChecked());
        creator.setCreator(_parameterCreator,
                           _inModelCreator,
                           _outModelCreator);
        _logMessage = creator.createStepFiles();

        if (ui->cb_actionStep->isChecked())
        {
            ActionCreator creator2(_pluginDirectory,"Step"+ui->le_name->text(),_pluginCode);
            _logMessage += creator2.createActionFiles();
        }

        done(QDialog::Accepted);
    }
}

void CreateStepDialog::reject()
{
    on_pb_clear_2_clicked();
    on_pb_clear_3_clicked();
    on_pb_clear_5_clicked();

    done(QDialog::Rejected);
}

void CreateStepDialog::closeEvent(QCloseEvent *event)
{
    Q_UNUSED(event);
    reject();
}

void CreateStepDialog::tabChanged(int tabNumber)
{
    buttonState();

    if (getCopyResults<INResultModel>(_modelIN) !=
        getCopyResults<OUTResultModel>(_modelOUT))
        _modelINmodified = true;

    if (tabNumber == 2 &&
        _modelOUTmodified &&
        getCopyResults<INResultModel>(_modelIN) != 0)
    {
        QString message = QString(tr("Vous avez déjà modifié les modèles de sortie contenant des copies\n"
                                     "de modèles d'entrée. Si vous modifiez les modèles d'entrée, cela\n"
                                     "réinitialisera les modèles de sortie."));
        QMessageBox::question(this, tr("Attention"), message);
    }

    // For copied models IN
    if (tabNumber == 3 && _modelINmodified)
        initCopy();
}

void CreateStepDialog::setFirstStep(bool isFirst)
{
    if (isFirst)
    {
        if (_modelIN->rowCount() != 0 || getCopyResults<INResultModel>(_modelIN) != 0)
        {
            QString message = QString(tr("Il y a des modèles d'entrée (voire copiés) existants.\n"
                                         "Changer de mode va les effacer. Voulez-vous continuer ?"));
            if (QMessageBox::question(this, tr("Attention"), message, QMessageBox::Yes|QMessageBox::No) == QMessageBox::No)
            {
                ui->rb_normal->setChecked(true);
                return;
            }
        }

        _modelIN->clear();
    }

    ui->tabWidget->setTabEnabled(2,!isFirst);
    ui->tabWidget->setTabVisible(2,!isFirst);
}

// Tab 1

void CreateStepDialog::fullNameChanged(const QString name)
{
    QString text = Tools::getTitleCase(name);
    ui->le_name->setText(text);
    ui->lb_begin->setText(StepCreator::getFullName(_pluginCode, text));
}

// Tab 2

void CreateStepDialog::on_treeView_2_clicked(const QModelIndex &index)
{
    treeViewSelect<AbstractParameter, AbstractParameterWidget>
        (index, _modelParameter, _activeWidgetParameter, _layoutParameter);

    // buttonState(); // Useless here
}

void CreateStepDialog::on_pb_add_2_clicked()
{
    QString selection = ui->cb_type_2->currentText();

         if (selection == "Boolean"     ) addParameter(new ParameterBool        ());
    else if (selection == "Integer"     ) addParameter(new ParameterInt         ());
    else if (selection == "Double"      ) addParameter(new ParameterDouble      ());
    else if (selection == "String"      ) addParameter(new ParameterString      ());
    else if (selection == "StringChoice") addParameter(new ParameterStringChoice());
    else if (selection == "ExcludeValue") addParameter(new ParameterExcludeValue());
    else if (selection == "FileChoice"  ) addParameter(new ParameterFileChoice  ());
    else if (selection == "TextLine"    ) addParameter(new ParameterTextLine    ());
    else if (selection == "EmptyLine"   ) addParameter(new ParameterEmptyLine   ());

    buttonState();
}

void CreateStepDialog::on_pb_up_2_clicked()
{
    moveItem(true);
}

void CreateStepDialog::on_pb_down_2_clicked()
{
    moveItem(false);
}

void CreateStepDialog::on_pb_delete_2_clicked()
{
    deleteItem<AbstractParameter,AbstractParameterWidget>
        (ui->treeView_2, _modelParameter, _activeWidgetParameter);

    buttonState();
}

void CreateStepDialog::on_pb_clear_2_clicked()
{
    deleteAllItems<AbstractParameterWidget>
        (ui->treeView_2, _modelParameter, _activeWidgetParameter);

    buttonState();
}

// Tab 3

void CreateStepDialog::on_treeView_3_clicked(const QModelIndex &index)
{
    treeViewSelect<AbstractInModel, AbstractInWidget>
        (index, _modelIN, _activeWidgetIN, _layoutIN);

    buttonState();
}

void CreateStepDialog::on_pb_addResult_3_clicked()
{
    addResult<INResultModel, AbstractInWidget>
        (ui->treeView_3, _modelIN, _activeWidgetIN, _layoutIN);

    _modelINmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_addGroup_3_clicked()
{
    addGroup<AbstractInModel, INGroupModel, AbstractInWidget>
        (ui->treeView_3, _modelIN, _activeWidgetIN, _layoutIN);

    _modelINmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_addItem_3_clicked()
{
    addItem<AbstractInModel, INItemModel, AbstractInWidget>
        (ui->treeView_3, _modelIN, _activeWidgetIN, _layoutIN);

    _modelINmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_delete_3_clicked()
{
    deleteItem<AbstractInModel,AbstractInWidget>
        (ui->treeView_3, _modelIN, _activeWidgetIN);

    _modelINmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_clear_3_clicked()
{
    deleteAllItems<AbstractInWidget>
        (ui->treeView_3, _modelIN, _activeWidgetIN);

    _modelINmodified = true;
    buttonState();
}

// Tab 4

void CreateStepDialog::on_treeView_5_clicked(const QModelIndex &index)
{
    treeViewSelect<AbstractOutModel, AbstractOutWidget>
        (index, _modelOUT, _activeWidgetOUT, _layoutOUT);

    buttonState();
}

void CreateStepDialog::on_pb_addResult_5_clicked()
{
    addResult<OUTResultModel, AbstractOutWidget>
        (ui->treeView_5, _modelOUT, _activeWidgetOUT, _layoutOUT);

    _modelOUTmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_addGroup_5_clicked()
{
    addGroup<AbstractOutModel, OUTGroupModel, AbstractOutWidget>
        (ui->treeView_5, _modelOUT, _activeWidgetOUT, _layoutOUT);

    _modelOUTmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_addItem_5_clicked()
{
    addItem<AbstractOutModel, OUTItemModel, AbstractOutWidget>
        (ui->treeView_5, _modelOUT, _activeWidgetOUT, _layoutOUT);

    _modelOUTmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_delete_5_clicked()
{
    deleteItem<AbstractOutModel,AbstractOutWidget>
        (ui->treeView_5, _modelOUT, _activeWidgetOUT);

    _modelOUTmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_clear_5_clicked()
{
    initCopy();
    // We don't use deleteAllItems here because we don't know if there are copies
    //deleteAllItems<AbstractOutWidget>
    //    (ui->treeView_5, _modelOUT, _activeWidgetOUT);

    buttonState();
}

void CreateStepDialog::on_pb_remove_5_clicked()
{
    QModelIndex index = ui->treeView_5->currentIndex();
    AbstractOutModel *item = (AbstractOutModel*) _modelOUT->itemFromIndex(index);
    if (item != NULL)
        if (item->getModelType() != AbstractOutModel::M_Result &&
            item->getStatus()    == AbstractOutModel::S_Copy)
            deleteItemCopy(item, _modelOUT, _activeWidgetOUT);

    _modelOUTmodified = true;
    buttonState();
}

void CreateStepDialog::on_pb_cancelRemove_5_clicked()
{
    QModelIndex index = ui->treeView_5->currentIndex();
    AbstractOutModel *item = (AbstractOutModel*) _modelOUT->itemFromIndex(index);
    if (item != NULL)
        if (item->getStatus() == AbstractOutModel::S_DeletedCopy)
            cancelDeleteCopy(item);

    _modelOUTmodified = true;
    buttonState();
}

// Private methods

void CreateStepDialog::buttonState()
{
    int tabNumber = ui->tabWidget->currentIndex();

    if(tabNumber == 1)
    {
        bool notAlone = !(_modelParameter->rowCount() < 2);
        ui->pb_up_2    ->setEnabled(notAlone);
        ui->pb_down_2  ->setEnabled(notAlone);
        bool notEmpty = !(_modelParameter->rowCount() == 0);
        ui->pb_delete_2->setEnabled(notEmpty);
        ui->pb_clear_2 ->setEnabled(notEmpty);
    }

    if(tabNumber == 2)
    {
        bool notEmpty = !(_modelIN->rowCount() == 0);

        ui->pb_delete_3  ->setEnabled(notEmpty);
        ui->pb_clear_3   ->setEnabled(notEmpty);
        ui->pb_addGroup_3->setEnabled(notEmpty);
        ui->pb_addItem_3 ->setEnabled(notEmpty);
    }

    if (tabNumber == 3)
    {
        if (_modelOUT->rowCount() == 0)
        {
            ui->pb_addGroup_5    ->setEnabled(false);
            ui->pb_addItem_5     ->setEnabled(false);
            ui->pb_remove_5      ->setEnabled(false);
            ui->pb_cancelRemove_5->setEnabled(false);
            ui->pb_delete_5      ->setEnabled(false);
            ui->pb_clear_5       ->setEnabled(false);
        }
        else
        {
            if (getCopyResults<INResultModel>(_modelIN) == 0)
            {
                ui->pb_addGroup_5    ->setEnabled(true );
                ui->pb_addItem_5     ->setEnabled(true );
                ui->pb_remove_5      ->setEnabled(false);
                ui->pb_cancelRemove_5->setEnabled(false);
                ui->pb_delete_5      ->setEnabled(true );
                ui->pb_clear_5       ->setEnabled(true );
            }
            else
            {
                QModelIndex index = ui->treeView_5->currentIndex();
                AbstractOutModel *item = (AbstractOutModel*) _modelOUT->itemFromIndex(index);

                if (item != NULL)
                {
                    bool isRoot        = (item == (AbstractOutModel*) _modelOUT->invisibleRootItem()->child(0));
                    bool isAdded       = (item->getStatus() == AbstractOutModel::S_Added      );
                    bool isDeletedCopy = (item->getStatus() == AbstractOutModel::S_DeletedCopy);

                    ui->pb_addGroup_5    ->setEnabled(!isDeletedCopy);
                    ui->pb_addItem_5     ->setEnabled(!isDeletedCopy);
                    ui->pb_remove_5      ->setEnabled(!isAdded && !isRoot);
                    ui->pb_cancelRemove_5->setEnabled(!isAdded && !isRoot);
                    ui->pb_delete_5      ->setEnabled(isAdded);
                    ui->pb_clear_5       ->setEnabled(true);
                }
                else
                {
                    ui->pb_addGroup_5    ->setEnabled(false);
                    ui->pb_addItem_5     ->setEnabled(false);
                    ui->pb_remove_5      ->setEnabled(false);
                    ui->pb_cancelRemove_5->setEnabled(false);
                    ui->pb_delete_5      ->setEnabled(false);
                    ui->pb_clear_5       ->setEnabled(false);
                }
            }
        }
    }
}

bool CreateStepDialog::checkInformation()
{
    bool ok = true;
    if (ui->le_name->text().isEmpty())
    {
        QString message = QString(tr("Le nom de l'étape n'est pas défini"));
        QMessageBox::warning(this, tr("Validation impossible"), message);
        ok = false;
    }
    if (ui->rb_canbeaddedfirst->isChecked() && _modelOUT->rowCount() == 0)
    {
        QString message = QString(tr("Pour une étape indépendente, veuillez renseigner au moins un modèle OUT"));
        QMessageBox::warning(this, tr("Validation impossible"), message);
        ok = false;
    }
    if (ui->rb_normal->isChecked() && _modelIN->rowCount() == 0)
    {
        QString message = QString(tr("Pour une étape normale, veuillez renseigner au moins un modèle IN"));
        QMessageBox::warning(this, tr("Validation impossible"), message);
        ok = false;
    }
    return ok;
}

bool CreateStepDialog::checkParameters(QStandardItemModel *_param, QString name)
{
    bool ok = true;
    int count = _param->rowCount();
    QList<QString> list;
    for (int i = 0 ; i < count && ok; i++)
    {
        AbstractParameter* item = (AbstractParameter*) _param->item(i);
        if (item->isDataParameter())
        {
            if (list.contains(item->getName()) || !item->isValid())
                ok = false;
            else
                list.append(item->getName());
        }
    }
    if (!ok)
    {
        QString message = QString(tr("Les noms des %1 ne sont pas tous définis et/ou uniques"));
        QMessageBox::warning(this, tr("Validation impossible"), message.arg(name));
    }

    return ok;
}

template<typename AbstractModel>
bool CreateStepDialog::checkModels(QStandardItemModel *_model, QString name)
{
    bool ok = true;
    int count = _model->rowCount();
    QList<QString> list;
    for (int i = 0 ; i < count && ok; i++)
    {
        AbstractModel* item = (AbstractModel*) _model->item(i);
        if (list.contains(item->getAlias()) || !item->isValid())
            ok = false;
        else
            list.append(item->getAlias());
    }
    if (!ok)
    {
        QString message = QString(tr("Les noms des %1 ne sont pas tous définis et/ou uniques"));
        QMessageBox::warning(this, tr("Validation impossible"), message.arg(name));
    }

    return ok;
}

void CreateStepDialog::moveItem(bool up)
{
    QModelIndex index = ui->treeView_2->currentIndex();
    AbstractParameter *item = (AbstractParameter*) _modelParameter->itemFromIndex(index);

    int row = item->row();
    int rowmax = _modelParameter->rowCount() - 1;

    if (_activeWidgetParameter!=NULL)
    {
        _layoutParameter->removeWidget(_activeWidgetParameter);
        _activeWidgetParameter->setParent(0);
        _activeWidgetParameter = NULL;
    }

    _modelParameter->takeRow(row);
    int newrow = row;
    if (up)
    {
        newrow--;
        if (newrow < 0) newrow = 0;
    }
    else
    {
        newrow++;
        if (newrow > rowmax) newrow = rowmax;
    }
    _modelParameter->insertRow(newrow, item);

    ui->treeView_2->setCurrentIndex(item->index());
    _activeWidgetParameter = item->getWidget();
    _layoutParameter->addWidget(_activeWidgetParameter);
}

void CreateStepDialog::initCopy()
{
    _outModelCreator->init();
    _activeWidgetOUT = NULL;
    ui->treeView_5->expandAll();
    _modelINmodified  = false;
    _modelOUTmodified = false;
}

template<typename ResultModel>
int CreateStepDialog::getCopyResults(QStandardItemModel* model)
{
    int copy = false;
    QStandardItem* root = model->invisibleRootItem();
    int count = root->rowCount();
    for (int i = 0 ; i < count ; i++)
    {
        ResultModel* result = (ResultModel*) root->child(i);
        if (result->isCopyResult()) copy++;
    }
    return copy;
}

template<typename AbstractModel,
         typename AbstractWidget>
void CreateStepDialog::treeViewSelect(const QModelIndex &index,
                                      QStandardItemModel* model,
                                      AbstractWidget* &activewidget,
                                      QVBoxLayout* &layout)
{
    AbstractModel *item = (AbstractModel*) model->itemFromIndex(index);
    if (activewidget!=NULL)
    {
        layout->removeWidget(activewidget);
        activewidget->setParent(0);
    }
    activewidget = item->getWidget();
    layout->addWidget(activewidget);
}

void CreateStepDialog::addParameter(QStandardItem* item)
{
    QStandardItem * root = _modelParameter->invisibleRootItem();
    root->appendRow(item);
    ui->treeView_2->setCurrentIndex(item->index());
    on_treeView_2_clicked(item->index());
    _activeWidgetParameter->setFocus();
}

template<typename ResultModel,
         typename AbstractWidget>
void CreateStepDialog::addResult(QTreeView* &treeview,
                                 QStandardItemModel* model,
                                 AbstractWidget* &activewidget,
                                 QVBoxLayout* &layout)
{
    QStandardItem *item = model->invisibleRootItem();
    ResultModel *item2 = new ResultModel();

    item->appendRow(item2);
    if (activewidget!=NULL)
    {
        layout->removeWidget(activewidget);
        activewidget->setParent(0);
    }
    activewidget = item2->getWidget();
    layout->addWidget(activewidget);

    treeview->setExpanded(treeview->currentIndex(), true);
    treeview->setCurrentIndex(item2->index());
    activewidget->setFocus();
}

template<typename AbstractModel,
         typename GroupModel,
         typename AbstractWidget>
void CreateStepDialog::addGroup(QTreeView* &treeview,
                                QStandardItemModel* model,
                                AbstractWidget* &activewidget,
                                QVBoxLayout* &layout)
{
    AbstractModel *item = (AbstractModel*)
        model->itemFromIndex(treeview->currentIndex());

    if (item == NULL)
        return;
    if (item->getModelType() != AbstractModel::M_Result &&
        item->getModelType() != AbstractModel::M_Group)
        return;
    if (item->getModelType() == AbstractModel::M_Result &&
        item->rowCount()!=0)
        return;

    GroupModel *item2 = new GroupModel();

    item->appendRow(item2);
    if (activewidget!=NULL)
    {
        layout->removeWidget(activewidget);
        activewidget->setParent(0);
    }
    activewidget = item2->getWidget();
    layout->addWidget(activewidget);

    treeview->setExpanded(treeview->currentIndex(), true);
    treeview->setCurrentIndex(item2->index());
    activewidget->setFocus();
}

template<typename AbstractModel,
         typename ItemModel,
         typename AbstractWidget>
void CreateStepDialog::addItem(QTreeView* &treeview,
                               QStandardItemModel* model,
                               AbstractWidget* &activewidget,
                               QVBoxLayout* &layout)
{
    AbstractModel *item = (AbstractModel*)
        model->itemFromIndex(treeview->currentIndex());

    if (item == NULL)
        return;
    if (item->getModelType() != AbstractModel::M_Group)
        return;

    ItemModel *item2 = new ItemModel();

    item->appendRow(item2);

    if (activewidget!=NULL)
    {
        layout->removeWidget(activewidget);
        activewidget->setParent(0);
    }
    activewidget = item2->getWidget();
    layout->addWidget(activewidget);

    treeview->setExpanded(treeview->currentIndex(), true);
    activewidget->setFocus();
}

QList<QStandardItem *> CreateStepDialog::getItemsToBeDeleted(QStandardItem* item)
{
    //delete all children of parent;
    QStandardItem * loopItem = item; //main loop item
    QList<QStandardItem *> carryItems; //Last In First Out stack of items
    QList<QStandardItem *> itemsToBeDeleted; //List of items to be deleted

    if (((AbstractOutModel*) item)->getStatus() != AbstractOutModel::S_Copy &&
        ((AbstractOutModel*) item)->getStatus() != AbstractOutModel::S_DeletedCopy)
    {
        while (loopItem->rowCount())
        {
            itemsToBeDeleted << loopItem->takeRow(0);
            //if the row removed has children:
            if (itemsToBeDeleted.at(0)->hasChildren())
            {
                //put on the stack the current loopItem
                carryItems << loopItem;
                //set the row with children as the loopItem
                loopItem = itemsToBeDeleted.at(0);
            }
            //if current loopItem has no more rows but carryItems list is not empty:
            if (!loopItem->rowCount() && !carryItems.isEmpty())
                loopItem = carryItems.takeFirst();
        }
    }

    return itemsToBeDeleted;
}

template<typename AbstractModel,
         typename AbstractWidget>
void CreateStepDialog::deleteItem(QTreeView* &treeview,
                                  QStandardItemModel* model,
                                  AbstractWidget* &activewidget)
{
    QModelIndex index = treeview->currentIndex();
    AbstractModel *item = (AbstractModel*) model->itemFromIndex(index);

    treeview->clearSelection();

    if (item != NULL)
    {
        QList<QStandardItem *> itemsToBeDeleted = getItemsToBeDeleted(item);

        if (item->parent()!=NULL)
            item->parent()->takeRow(item->row());
        else
            model->invisibleRootItem()->takeRow(item->row());

        itemsToBeDeleted.append(item);

        while (!itemsToBeDeleted.isEmpty())
        {
            AbstractModel* itemToDelete = (AbstractModel*) itemsToBeDeleted.takeLast();
            if (itemToDelete->getWidget() == activewidget)
                activewidget = NULL;
            delete itemToDelete;
        }
    }
}

template<typename AbstractWidget>
void CreateStepDialog::deleteAllItems(QTreeView* &treeview,
                                      QStandardItemModel* model,
                                      AbstractWidget* &activewidget)
{
    treeview->clearSelection();
    QStandardItem* item = model->invisibleRootItem();
    QList<QStandardItem *> itemsToBeDeleted = getItemsToBeDeleted(item);
    qDeleteAll(itemsToBeDeleted);
    activewidget = NULL;
}

void CreateStepDialog::deleteItemCopy(AbstractOutModel* item,
                                      QStandardItemModel* model,
                                      AbstractOutWidget* &activeWidget)
{
    if (item != NULL)
    {
        if (item->getStatus() == AbstractOutModel::S_Added)
        {
            QList<QStandardItem *> itemsToBeDeleted = getItemsToBeDeleted(item);

            if (item->parent()!=NULL)
                item->parent()->takeRow(item->row());
            else
                model->invisibleRootItem()->takeRow(item->row());

            itemsToBeDeleted.append(item);

            while (!itemsToBeDeleted.isEmpty())
            {
                AbstractOutModel* itemToDelete = (AbstractOutModel*) itemsToBeDeleted.takeLast();
                if (itemToDelete->getWidget() == activeWidget)
                    activeWidget = NULL;
                delete itemToDelete;
            }
        }
        else
        {
            item->setDeleted();
            int count = item->rowCount();
            for (int i = 0 ; i < count ; i++)
            {
                AbstractOutModel* item2 = (AbstractOutModel*) item->child(i);
                if (item2 != NULL)
                    deleteItemCopy(item2, model, activeWidget);
            }
        }
    }
}

void CreateStepDialog::cancelDeleteCopy(AbstractOutModel* item)
{
    if (item != NULL)
    {
        if (item->getStatus() == AbstractOutModel::S_DeletedCopy)
        {
            item->setNotDeleted();
            AbstractOutModel* item2 = (AbstractOutModel*) item->parent();
            if (item2 != NULL)
                cancelDeleteCopy((AbstractOutModel*)item->parent());
        }
    }
}