449 lines
16 KiB
C++
Executable File
449 lines
16 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* template-Editor
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
*/
|
|
|
|
#include "participant_template_edit.h"
|
|
#include "ui_participant_template_edit.h"
|
|
|
|
#include <Plugins/ParticipantManagement/Gui/Common/participant_template_edit_item.h>
|
|
#include <Plugins/ParticipantManagement/Gui/Common/participant_edit_model.h>
|
|
#include "participant_template_chooser_frameless.h"
|
|
#include <ParticipantManagement/Gui/Common/participant_firing_unit_validator.h>
|
|
|
|
#include <QMenu>
|
|
|
|
#include <nglwidgets/ngltreeitem.h>
|
|
#include <LtsPrinting/printing.h>
|
|
#include <QTreeView>
|
|
|
|
namespace ParticipantManagement
|
|
{
|
|
ParticipantTemplateEdit::ParticipantTemplateEdit(LtsSession::LtsSession *session,
|
|
int rootId,
|
|
bool asSupportService,
|
|
QWidget *parent)
|
|
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
|
|
, m_rootId(rootId)
|
|
, m_asSupportService(asSupportService)
|
|
, m_bNeedCommitModifedData(true)
|
|
, m_model(nullptr)
|
|
, m_actionInsertTemplate(nullptr)
|
|
, m_actionSaveAsNewTemplate(nullptr)
|
|
, m_actionRemove(nullptr)
|
|
, m_actionEdit(nullptr)
|
|
, m_requestHelper(new LtsUtils::RequestHelper(this))
|
|
, m_dtc(nullptr)
|
|
, m_ftc(nullptr)
|
|
, m_ppmGuiCbxIfc(nullptr)
|
|
, m_session(session)
|
|
, m_ui(new Ui::ParticipantTemplateEdit)
|
|
, m_logger(getLogger("ParticipantTemplateEdit"))
|
|
{
|
|
m_ui->setupUi(this);
|
|
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &ParticipantTemplateEdit::onAddItem);
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ParticipantTemplateEdit::onEditItem);
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &ParticipantTemplateEdit::onRemoveItem);
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &ParticipantTemplateEdit::onPrint);
|
|
|
|
// ein Apply führt zu aufwendigen Update im Template-Baum - erst einmal hide da Ok ausreichen sollte
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
|
|
|
|
if (m_asSupportService)
|
|
setOnlineHelpFilename(QStringLiteral("Administrator-Support_Templates"));
|
|
else
|
|
setOnlineHelpFilename(QStringLiteral("Administrator-Participant_Templates"));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ParticipantTemplateEdit::~ParticipantTemplateEdit()
|
|
{
|
|
delete m_ui;
|
|
}
|
|
|
|
void ParticipantTemplateEdit::retranslate()
|
|
{
|
|
translate(m_ui, m_asSupportService ? tr("Support Template Editor") : tr("Participant Template Editor"));
|
|
}
|
|
|
|
bool ParticipantTemplateEdit::init(const std::shared_ptr<ParticipantManagement::Interface::Dtc> &dtc,
|
|
const std::shared_ptr<ParticipantManagement::Interface::Ftc> &ftc,
|
|
const std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
|
|
const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asbIfc)
|
|
{
|
|
if (!dtc || !ftc || !ppmGuiCbxIfc)
|
|
return false;
|
|
m_dtc = dtc;
|
|
m_ftc = ftc;
|
|
m_ppmGuiCbxIfc = ppmGuiCbxIfc;
|
|
m_asbIfc = asbIfc;
|
|
|
|
m_model = new ParticipantTemplateEditModel(this, m_dtc, asbIfc, m_rootId);
|
|
|
|
// View treeView :
|
|
m_ui->treeViewEdit->setModel(m_model);
|
|
m_ui->treeViewEdit->hideColumn(ParticipantTemplateEditModel::ColTypeClass);
|
|
m_ui->treeViewEdit->expandAll();
|
|
for (int i = 0; i < m_model->columnCount(QModelIndex()); ++i)
|
|
m_ui->treeViewEdit->resizeColumnToContents(i);
|
|
m_ui->treeViewEdit->header()->resizeSection(0, m_ui->treeViewEdit->columnWidth(0) + m_ui->treeViewEdit->iconSize().width() + 10);
|
|
|
|
QPushButton *pbInsert = m_buttonBox->getButton(LtsWidgets::DialogButton::Import);
|
|
pbInsert->setText(tr("Insert Template"));
|
|
pbInsert->setVisible(true);
|
|
connect(pbInsert, &QPushButton::clicked,
|
|
this, &ParticipantTemplateEdit::onInsertTemplate);
|
|
|
|
QPushButton *pbSaveAs = m_buttonBox->getButton(LtsWidgets::DialogButton::Export);
|
|
pbSaveAs->setText(tr("Save as Template"));
|
|
pbSaveAs->setVisible(true);
|
|
connect(pbSaveAs, &QPushButton::clicked,
|
|
this, &ParticipantTemplateEdit::onSaveAsNewTemplate);
|
|
|
|
// ContextMenu :
|
|
m_ui->treeViewEdit->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(m_ui->treeViewEdit, &QTreeView::customContextMenuRequested,
|
|
this, &ParticipantTemplateEdit::slotCustomContextMenuRequested);
|
|
connect(m_ui->treeViewEdit, &QTreeView::doubleClicked,
|
|
this, &ParticipantTemplateEdit::onDoubleClicked);
|
|
|
|
// ContextMenu actions :
|
|
m_actionInsertTemplate = new QAction(pbInsert->icon(), pbInsert->text(), this);
|
|
connect(m_actionInsertTemplate, &QAction::triggered,
|
|
this, &ParticipantTemplateEdit::onInsertTemplate);
|
|
|
|
m_actionSaveAsNewTemplate = new QAction(pbSaveAs->icon(), pbSaveAs->text(), this);
|
|
connect(m_actionSaveAsNewTemplate, &QAction::triggered,
|
|
this, &ParticipantTemplateEdit::onSaveAsNewTemplate);
|
|
|
|
QPushButton *pbRemove = m_buttonBox->getButton(LtsWidgets::DialogButton::Remove);
|
|
m_actionRemove = new QAction(pbRemove->icon(), pbRemove->text(), this);
|
|
connect(m_actionRemove, &QAction::triggered,
|
|
this, &ParticipantTemplateEdit::onRemoveItem);
|
|
|
|
QPushButton *pbEdit = m_buttonBox->getButton(LtsWidgets::DialogButton::Edit);
|
|
m_actionEdit = new QAction(pbEdit->icon(), pbEdit->text(), this);
|
|
connect(m_actionEdit, &QAction::triggered, this,
|
|
&ParticipantTemplateEdit::onEditItem);
|
|
|
|
// SelectionModel :
|
|
QItemSelectionModel *selectionModel = m_ui->treeViewEdit->selectionModel();
|
|
connect(selectionModel, &QItemSelectionModel::selectionChanged,
|
|
this, &ParticipantTemplateEdit::onSelectionChanged);
|
|
selectionModel->clearSelection();
|
|
enaDisa();
|
|
|
|
|
|
connect(m_model, &ParticipantTemplateEditModel::internalDataChanged, this, &ParticipantTemplateEdit::slotChangesMade);
|
|
|
|
if (m_firingUnitValidator)
|
|
delete m_firingUnitValidator;
|
|
m_firingUnitValidator = new FiringUnitValidator(m_dtc, this);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onModifyTemplateDataReply(const Core::FunctionReplyObject &replyObject)
|
|
{
|
|
enaDisa();
|
|
if (m_bNeedCommitModifedData && !replyObject.error())
|
|
m_model->dataCommitted();
|
|
m_requestHelper->requestReply(replyObject);
|
|
}
|
|
|
|
QModelIndex ParticipantTemplateEdit::selectedIndexView() const
|
|
{
|
|
QItemSelectionModel *selectionModel = m_ui->treeViewEdit->selectionModel();
|
|
QModelIndexList indexL = selectionModel->selectedRows(0);
|
|
if (indexL.size() == 0)
|
|
return QModelIndex();
|
|
|
|
return indexL.at(0);
|
|
}
|
|
|
|
bool ParticipantTemplateEdit::isContainer(const QModelIndex &index)
|
|
{
|
|
Q_UNUSED(index);
|
|
if (!selectedIndexView().isValid())
|
|
return false;
|
|
int typeId = m_model->privateData(selectedIndexView())->data().value<ParticipantManagement::TemplateData>().typeId();
|
|
if (typeId <= 0)
|
|
return false;
|
|
|
|
if (m_asSupportService)
|
|
return m_dtc->type(typeId).typeClass() == ParticipantManagement::TypeClass_def::SupportUnit;
|
|
else
|
|
return m_dtc->type(typeId).typeClass() == ParticipantManagement::TypeClass_def::Unit;
|
|
|
|
}
|
|
|
|
void ParticipantTemplateEdit::enaDisa()
|
|
{
|
|
QModelIndex selIndex = selectedIndexView();
|
|
bool enableAdd = false;
|
|
bool enableEdit = false;
|
|
bool enableRemove = false;
|
|
bool enableSaveAsTemplate = false;
|
|
|
|
if (selIndex.isValid())
|
|
{
|
|
if (isContainer(selIndex)) //only add to units
|
|
{
|
|
enableSaveAsTemplate = true;
|
|
enableAdd = true;
|
|
|
|
if (m_firingUnitValidator)
|
|
enableAdd &= m_firingUnitValidator->hasUnitCapacities(m_model, selIndex);
|
|
}
|
|
enableEdit = true;
|
|
enableRemove = selIndex.parent().isValid();
|
|
}
|
|
|
|
m_actionInsertTemplate->setEnabled(enableAdd);
|
|
m_actionSaveAsNewTemplate->setEnabled(enableSaveAsTemplate);
|
|
m_actionRemove->setEnabled(enableRemove);
|
|
m_actionEdit->setEnabled(enableEdit);
|
|
|
|
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, enableAdd);
|
|
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, m_actionEdit->isEnabled());
|
|
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, m_actionRemove->isEnabled());
|
|
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Import, m_actionInsertTemplate->isEnabled());
|
|
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Export, m_actionSaveAsNewTemplate->isEnabled());
|
|
}
|
|
|
|
|
|
void ParticipantTemplateEdit::removeCurrentRow()
|
|
{
|
|
QModelIndex selIndex = selectedIndexView();
|
|
NGLTreeItem *item = m_model->privateData(selIndex);
|
|
ParticipantManagement::TemplateData tmpl = item->data().value<ParticipantManagement::TemplateData>();
|
|
|
|
const bool isRootTemplate = (tmpl.templateId() == m_rootId);
|
|
if (!selIndex.isValid() || isRootTemplate)
|
|
return;
|
|
/** with or without question :
|
|
if(m_model->hasChildren(selIndex)) {
|
|
if(QMessageBox::No == QMessageBox::question(this,
|
|
tr ("Einheit loeschen"),
|
|
tr("Moechten Sie das Element mit allen Untereinheiten wirklich loeschen?"),
|
|
QMessageBox::Yes|QMessageBox::No)) {
|
|
return;
|
|
}
|
|
} else { // no childs :
|
|
if(QMessageBox::No == QMessageBox::question(this,
|
|
tr("Einheit loeschen"),
|
|
tr("Moechten Sie das Element wirklich loeschen?"),
|
|
QMessageBox::Yes|QMessageBox::No)) {
|
|
return;
|
|
}
|
|
}
|
|
*/
|
|
m_model->onDeleteRow(selIndex, true);
|
|
}
|
|
|
|
|
|
//slots
|
|
|
|
void ParticipantTemplateEdit::onAddItem()
|
|
{
|
|
ParticipantTemplateEditItem *newItemDlg = new ParticipantTemplateEditItem(m_asSupportService,
|
|
m_session,
|
|
this);
|
|
const bool addItem = true;
|
|
ParticipantManagement::TemplateData data = ParticipantManagement::TemplateData();
|
|
QModelIndex selIndex = selectedIndexView();
|
|
if (selIndex.isValid())
|
|
{
|
|
ParticipantManagement::TemplateData dataAll = m_model->privateData(selIndex)->data().value<ParticipantManagement::TemplateData>();
|
|
data.designator(dataAll.designator());
|
|
data.tacticalIdentifier(dataAll.tacticalIdentifier());
|
|
}
|
|
|
|
if (!newItemDlg->init(selIndex, m_dtc, m_ppmGuiCbxIfc, m_asbIfc, data, addItem))
|
|
{
|
|
delete newItemDlg;
|
|
return;
|
|
}
|
|
newItemDlg->setUsedEquipmentNumbers(m_model->usedEquipmentNumbers());
|
|
newItemDlg->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
connect(newItemDlg, &ParticipantTemplateEditItem::rejected, newItemDlg, &ParticipantTemplateEditItem::deleteLater);
|
|
connect(newItemDlg, &ParticipantTemplateEditItem::addItem, this, &ParticipantTemplateEdit::onAddItemToModel);
|
|
connect(this, &ParticipantTemplateEdit::usedEquipmentNumbersChanged, newItemDlg, &ParticipantTemplateEditItem::setUsedEquipmentNumbers);
|
|
|
|
if (m_firingUnitValidator)
|
|
{
|
|
newItemDlg->setIsAdler(m_firingUnitValidator->isAdler(m_model, selIndex));
|
|
const int unitGearClassType = m_firingUnitValidator->getGearClassType(m_model, selIndex);
|
|
|
|
newItemDlg->setFiringUnitRestrictions(m_model, false, m_firingUnitValidator->getRestrictions(m_model, selIndex), m_firingUnitValidator, unitGearClassType);
|
|
|
|
connect(newItemDlg, &ParticipantTemplateEditItem::addItem, this, [this, newItemDlg, unitGearClassType] (const QModelIndex &parent, const TemplateData &newData)
|
|
{
|
|
Q_UNUSED(newData)
|
|
|
|
if (!newItemDlg || !m_firingUnitValidator)
|
|
return;
|
|
|
|
newItemDlg->setFiringUnitRestrictions(m_model, false, m_firingUnitValidator->getRestrictions(m_model, parent), m_firingUnitValidator, unitGearClassType);
|
|
});
|
|
}
|
|
|
|
newItemDlg->show();
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onEditItem()
|
|
{
|
|
QModelIndex selIndex = selectedIndexView();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
ParticipantManagement::TemplateData data = m_model->privateData(selIndex)->data().value<ParticipantManagement::TemplateData>();
|
|
|
|
ParticipantTemplateEditItem *newItemDlg = new ParticipantTemplateEditItem(m_asSupportService,
|
|
m_session,
|
|
this);
|
|
if (!newItemDlg->init(selIndex, m_dtc, m_ppmGuiCbxIfc, m_asbIfc, data))
|
|
{
|
|
delete newItemDlg;
|
|
return;
|
|
}
|
|
newItemDlg->setUsedEquipmentNumbers(m_model->usedEquipmentNumbers());
|
|
newItemDlg->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
connect(newItemDlg, &ParticipantTemplateEditItem::updateItem, this, &ParticipantTemplateEdit::onModifyItemInModel);
|
|
connect(this, &ParticipantTemplateEdit::usedEquipmentNumbersChanged, newItemDlg, &ParticipantTemplateEditItem::setUsedEquipmentNumbers);
|
|
|
|
if (m_firingUnitValidator)
|
|
{
|
|
const int unitGearClassType = m_firingUnitValidator->getGearClassType(m_model, selIndex);
|
|
newItemDlg->setFiringUnitRestrictions(m_model, true, m_firingUnitValidator->getRestrictions(m_model, selIndex), m_firingUnitValidator, unitGearClassType);
|
|
}
|
|
newItemDlg->show();
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onRemoveItem()
|
|
{
|
|
removeCurrentRow();
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onPrint()
|
|
{
|
|
LtsPrinting::printView(m_session, this, m_ui->treeViewEdit );
|
|
}
|
|
|
|
bool ParticipantTemplateEdit::apply()
|
|
{
|
|
ModifyTemplateDataRequest req;
|
|
req.data(m_model->templateData());
|
|
if (req.data().size() == 0)
|
|
return true;
|
|
|
|
m_bNeedCommitModifedData = true;
|
|
|
|
return m_requestHelper->startSingleRequest([this, req]()
|
|
{
|
|
return m_ftc->modifyTemplateDataRequest(req, this);
|
|
});
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onInsertTemplate()
|
|
{
|
|
QModelIndex selIndex = selectedIndexView();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
ParticipantTemplateChooserFrameless *templateChooser = new ParticipantTemplateChooserFrameless(m_session, this);
|
|
if (!templateChooser->init(m_dtc))
|
|
{
|
|
delete templateChooser;
|
|
return;
|
|
}
|
|
|
|
connect(templateChooser, &ParticipantTemplateChooserFrameless::selectedTemplate, this, &ParticipantTemplateEdit::onAddTemplateToModel);
|
|
connect(templateChooser, &ParticipantTemplateChooserFrameless::rejected, templateChooser, &ParticipantTemplateChooserFrameless::deleteLater);
|
|
|
|
templateChooser->show();
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onAddTemplateToModel(int templateId)
|
|
{
|
|
m_model->onInsertTemplate(templateId, selectedIndexView(), true);
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onSaveAsNewTemplate()
|
|
{
|
|
QModelIndex selIndex = selectedIndexView();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
ModifyTemplateDataRequest req;
|
|
req.data(m_model->templateDataAsCopy(selIndex));
|
|
if (req.data().size() == 0)
|
|
return;
|
|
|
|
m_bNeedCommitModifedData = false;
|
|
m_requestHelper->startSingleRequest([this, req]()
|
|
{
|
|
return m_ftc->modifyTemplateDataRequest(req, this);
|
|
});
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onAddItemToModel(const QModelIndex &parent, const TemplateData &templateData)
|
|
{
|
|
bool ret = m_model->onInsertRow(parent, templateData);
|
|
int typeId = m_model->privateData(parent)->data().value<ParticipantManagement::TemplateData>().typeId();
|
|
if (!ret && typeId <= 0)
|
|
return;
|
|
Type type = m_dtc->type(typeId);
|
|
if (type.typeClass() == TypeClass::Unit ||
|
|
type.typeClass() == TypeClass::SupportUnit)
|
|
{
|
|
m_ui->treeViewEdit->setExpanded(m_ui->treeViewEdit->selectionModel()->selectedIndexes().at(0), true);
|
|
}
|
|
|
|
emit usedEquipmentNumbersChanged(m_model->usedEquipmentNumbers());
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onModifyItemInModel(const QModelIndex &index, const TemplateData &editData)
|
|
{
|
|
m_model->onUpdateRow(index, editData);
|
|
emit usedEquipmentNumbersChanged(m_model->usedEquipmentNumbers());
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onDoubleClicked(const QModelIndex &selIndex)
|
|
{
|
|
if (!selIndex.isValid())
|
|
return;
|
|
onEditItem();
|
|
}
|
|
|
|
void ParticipantTemplateEdit::onSelectionChanged(const QItemSelection & /*selected*/,
|
|
const QItemSelection & /*deselected*/)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onSelectionChanged";
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
void ParticipantTemplateEdit::slotCustomContextMenuRequested(const QPoint &position)
|
|
{
|
|
QModelIndex selIndex = selectedIndexView();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
enaDisa();
|
|
|
|
QMenu menu(m_ui->treeViewEdit);
|
|
menu.addAction(m_actionInsertTemplate);
|
|
menu.addAction(m_actionSaveAsNewTemplate);
|
|
menu.addSeparator();
|
|
menu.addAction(m_actionRemove);
|
|
menu.addSeparator();
|
|
menu.addAction(m_actionEdit);
|
|
menu.exec(m_ui->treeViewEdit->viewport()->mapToGlobal(position));
|
|
}
|
|
|
|
} //namespace ParticipantManagement
|