Initial commit

Lts/Plugins/ParticipantManagement/Gui/Common/participant_template_edit_item.cpp

@@ -0,0 +1,359 @@
+/**
+  * @RDE_HEADER@
+  * HMI Plugin for MeteoDataManagement - Meteo Data Overview Dialog
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Patric Karwat, SLSE, 2016-10-05
+  */
+
+#include "participant_template_edit_item.h"
+#include "ui_participant_edit_item_widget_base.h"
+#include <Plugins/ParticipantManagement/ppm_gui_combobox_plugin_interface.h>
+#include <ParticipantManagement/ppm_translation.h>
+#include <QStandardItemModel>
+
+#include <LtsSession/lts_session_manager.h>
+
+namespace ParticipantManagement
+{
+
+//
+// ParticipantTemplateEditItemWidget
+//
+ParticipantTemplateEditItemWidget::ParticipantTemplateEditItemWidget(bool asSupportService,
+                                                                     LtsSession::LtsSession *session,
+                                                                     QWidget *parent)
+  : ParticipantEditItemWidgetBase(asSupportService, session, parent)
+{
+  m_ui->lbInfo->hide();
+  m_ui->leInfo->hide();
+  m_ui->lbSign->hide();
+  m_ui->leSign->hide();
+  m_ui->tbAssignment->hide();
+}
+
+bool ParticipantTemplateEditItemWidget::init(const QModelIndex &workingIndex,
+                                             const std::shared_ptr<ParticipantManagement::Interface::Dtc> &dtc,
+                                             const std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
+                                             const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
+                                             const ParticipantManagement::TemplateData &data,
+                                             const bool addItem)
+{
+  m_workingIndex = workingIndex;
+  m_editData = data;
+  m_bEditMode = m_editData.typeId() > 0;
+
+  return ParticipantEditItemWidgetBase::init(dtc, ppmGuiCbxIfc, asb, addItem);
+}
+
+void ParticipantTemplateEditItemWidget::setFiringUnitRestrictions(ParticipantTemplateEditModel *model, bool isEdit, const FiringUnitValidator::FiringUnitRestrictions &restrictions, FiringUnitValidator *firingUnitValidator, const int &unitGearClassType)
+{
+  if (!firingUnitValidator || !model)
+    return;
+
+  if (restrictions.testFlag(FiringUnitValidator::NO_TYPE_CHANGE_ALLOWED))
+  {
+    m_ui->cbTypeClass->setDisabled(true);
+    m_ui->cbType->setDisabled(true);
+
+    if (isEdit) // if we are in edit mode (and not add), type and typeclass are already set where as want them to be
+      return;
+
+    const Type allowedType = firingUnitValidator->getAllowedType(model, m_workingIndex);
+
+    if (allowedType == Type())
+      return;
+
+    m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(allowedType.typeClass().underlying()));
+    m_ui->cbType->setCurrentIndex(m_ui->cbType->findData(allowedType.id()));
+
+    return;
+  }
+
+  if (restrictions.testFlag(FiringUnitValidator::ONLY_SAME_GEAR_CLASS_ARTILLERY_ALLOWED))
+  {
+    if (isEdit)
+      return;
+
+    const QVector<Type> allowedTypes = firingUnitValidator->artilleryParticipantTypes();
+
+    m_ui->cbTypeClass->setDisabled(true);
+    m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(allowedTypes.at(0).typeClass().underlying()));
+
+    QSignalBlocker typeSignalBlocker(m_ui->cbType);
+
+
+    m_ui->cbType->clear();
+
+    std::function<bool(Type)> funcIsSameGearType = [=](const Type &t)
+    {
+      if (m_isAdler)
+        return m_dtc->isAdlerType(t.id()) && (firingUnitValidator->getGearClassType(t.id()) == unitGearClassType);
+      return firingUnitValidator->getGearClassType(t.id()) == unitGearClassType;
+    };
+    QVector<Type>::ConstIterator typeIterator = std::find_if(allowedTypes.begin(), allowedTypes.end(), funcIsSameGearType);
+
+    if(typeIterator != allowedTypes.end())
+    {
+      m_ui->cbType->setDisabled(true);
+      m_ui->cbType->addItem(ParticipantManagement::trTypeName(typeIterator->name()), typeIterator->id());
+    }
+    else
+    {
+      for (const Type &currentType : allowedTypes)
+        m_ui->cbType->addItem(ParticipantManagement::trTypeName(currentType.name()), currentType.id());
+      m_ui->cbType->model()->sort(0);
+    }
+
+    m_ui->cbType->setCurrentIndex(0);
+    return;
+  }
+
+  if (isEdit && restrictions.testFlag(FiringUnitValidator::NO_FIRING_UNIT_TYPE_ALLOWED))
+  {
+    m_disabledTypeIds.unite(firingUnitValidator->firingUnitTypeIds());
+
+    QStandardItemModel *cbTypeModel = qobject_cast<QStandardItemModel *>(m_ui->cbType->model());
+
+    if (cbTypeModel == nullptr)
+      return;
+
+    for (int row = 0; row < m_ui->cbType->count(); ++row)
+    {
+      QStandardItem *item = cbTypeModel->item(row);
+      int typeId = item->data(Qt::UserRole).toInt();
+
+      if (!m_disabledTypeIds.contains(typeId))
+        continue;
+
+      item->setFlags(Qt::NoItemFlags);
+    }
+  }
+
+  if (restrictions.testFlag(FiringUnitValidator::NO_ARTILLERY_PARTICIPANTS_ALLOWED))
+  {
+    m_disabledTypeIds.unite(firingUnitValidator->artilleryParticipantTypeIds());
+
+    QStandardItemModel *cbTypeModel = qobject_cast<QStandardItemModel *>(m_ui->cbType->model());
+
+    if (cbTypeModel == nullptr)
+      return;
+
+    for (int row = 0; row < m_ui->cbType->count(); ++row)
+    {
+      QStandardItem *item = cbTypeModel->item(row);
+      int typeId = item->data(Qt::UserRole).toInt();
+
+      if (!m_disabledTypeIds.contains(typeId))
+        continue;
+
+      item->setFlags(Qt::NoItemFlags);
+    }
+  }
+}
+
+void ParticipantTemplateEditItemWidget::setData()
+{
+  m_ui->leDesignator->setText(QString::fromStdString(m_editData.designator()));
+  m_ui->leTactIdent->setText(QString::fromStdString(m_editData.tacticalIdentifier()));
+
+  Type type = m_dtc->type(m_editData.typeId());
+  m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(type.typeClass().underlying()));
+  m_ui->cbType->setCurrentIndex(m_ui->cbType->findData(type.id()));
+
+  // set EqNr after all cbx change
+  m_ui->sbEquipNr->setValue(m_editData.equipmentNumber());
+
+  // Not templates for Externals.
+  m_ui->cbExternal->hide();
+  m_ui->cbExternal->setChecked(false);
+  m_ui->lblExternal->hide();
+
+  // nach den Setzen des Typs, sonst wird Default Typ-Symbol benutzt...
+  onChangeSymbol(QString::fromStdString(m_editData.symbol()));
+}
+
+void ParticipantTemplateEditItemWidget::setDesignatorData()
+{
+  m_ui->leDesignator->setText(QString::fromStdString(m_editData.designator()));
+  m_ui->leTactIdent->setText(QString::fromStdString(m_editData.tacticalIdentifier()));
+}
+
+void ParticipantTemplateEditItemWidget::onAddItem()
+{
+  ParticipantManagement::TemplateData newTemplateParticipant;
+  newTemplateParticipant.designator() = m_ui->leDesignator->text().toStdString();
+  newTemplateParticipant.tacticalIdentifier() = m_ui->leTactIdent->text().toStdString();
+  newTemplateParticipant.symbol(m_sidc.toStdString());
+  newTemplateParticipant.typeId(m_ui->cbType->currentData().toInt());
+
+  const int equipNo = m_ui->sbEquipNr->value();
+  if (!checkEquipNo(equipNo))
+    return;
+  newTemplateParticipant.equipmentNumber(equipNo);
+
+  DEBUG_LOG(m_logger) << "adding item: " << newTemplateParticipant;
+  emit addItem(m_workingIndex, newTemplateParticipant);
+
+  if (equipNo > 0)
+    m_ui->sbEquipNr->setValue(equipNo + 1);
+}
+
+bool ParticipantTemplateEditItemWidget::onEditItem()
+{
+  m_editData.designator() = m_ui->leDesignator->text().toStdString();
+  m_editData.tacticalIdentifier() = m_ui->leTactIdent->text().toStdString();
+  m_editData.symbol(m_sidc.toStdString());
+  m_editData.typeId(m_ui->cbType->currentData().toInt());
+
+  //eqNr is set
+  const int equipNo = m_ui->sbEquipNr->value();
+  if (!checkEquipNo(equipNo))
+    return false;
+  m_editData.equipmentNumber(equipNo);
+
+  DEBUG_LOG(m_logger) << "edit item: " << m_editData;
+  emit updateItem(m_workingIndex, m_editData);
+  emit readyToClose();
+  return true;
+}
+
+bool ParticipantTemplateEditItemWidget::checkEquipNo(int equipNo)
+{
+  if (equipNo > 0)
+  {
+    if (equipNo < m_typeMinimum)
+    {
+      //eqNr is below minimum!
+      m_ui->lbMinMaxEquipNr->setText(QStringLiteral("<span style=\"color:#aa0000;\">%1</span>").arg(equipNo));
+      return false;
+    }
+    if (m_editData.equipmentNumber() != equipNo)
+    {
+      //eqNr is in range (max is set in sp directly)
+      if (m_usedEquipmentNumbers.contains(equipNo))
+      {
+        const QString msg = tr("The equipment number is already used by another participant in this template");
+        LtsWidgets::LtsMessageDialog::showMessage(this,
+                                                  msg,
+                                                  tr("Equipment Number already in use"));
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+
+//
+// ParticipantTemplateEditItem
+//
+ParticipantTemplateEditItem::ParticipantTemplateEditItem(bool asSupportService,
+                                                         LtsSession::LtsSession *session,
+                                                         QWidget *parent)
+  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
+  , m_editItemWidget(new ParticipantTemplateEditItemWidget(asSupportService, session, parent))
+  , m_buttonBox(new LtsWidgets::LtsDialogButtonBox(this))
+{
+  //HACK as close is not allowed directly
+
+  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &ParticipantTemplateEditItem::close);
+  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::readyToClose, this, &ParticipantTemplateEditItem::close);
+
+  //connect to other signals
+  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::addItem, this, &ParticipantTemplateEditItem::addItem);
+  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::updateItem, this, &ParticipantTemplateEditItem::updateItem);
+
+  //hide ok and aplly
+  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
+  m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
+}
+
+bool ParticipantTemplateEditItem::init(const QModelIndex &workingIndex,
+                                       const std::shared_ptr<Interface::Dtc> &dtc,
+                                       const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
+                                       const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
+                                       const TemplateData &data,
+                                       const bool addItem)
+{
+  if (!m_editItemWidget->init(workingIndex, dtc, ppmGuiCbxIfc, asb, data, addItem))
+    return false;
+
+
+  QVBoxLayout *layout = new QVBoxLayout;
+  layout->addWidget(m_editItemWidget);
+  layout->addWidget(m_buttonBox);
+  setLayout(layout);
+
+  if (data.typeId() > 0)
+  {
+    m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, m_editItemWidget, &ParticipantTemplateEditItemWidget::onEditItem);
+    m_buttonBox->getButton(LtsWidgets::DialogButton::Edit)->setText(tr("Apply"));
+  }
+  else
+  {
+    m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, m_editItemWidget, &ParticipantTemplateEditItemWidget::onAddItem);
+  }
+
+  return true;
+}
+
+void ParticipantTemplateEditItem::setFiringUnitRestrictions(ParticipantTemplateEditModel *model, bool isEdit, const FiringUnitValidator::FiringUnitRestrictions &restrictions, FiringUnitValidator *firingUnitValidator, const int unitGearClassType)
+{
+  if (restrictions == FiringUnitValidator::NO_RESTRICTION)
+    return;
+
+  if (restrictions.testFlag(FiringUnitValidator::IS_AT_MAX_CAPACITY))
+    m_buttonBox->getButton(LtsWidgets::DialogButton::Add)->setDisabled(true);
+
+  if (m_editItemWidget)
+    m_editItemWidget->setFiringUnitRestrictions(model, isEdit, restrictions, firingUnitValidator, unitGearClassType);
+}
+
+//
+// ParticipantTemplateEditItemTab
+//
+ParticipantTemplateEditItemTab::ParticipantTemplateEditItemTab(bool asSupportService,
+                                                               LtsSession::LtsSession *session,
+                                                               QWidget *parent)
+  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
+  , m_editItemWidget(new ParticipantTemplateEditItemWidget(asSupportService, session, this))
+{
+  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::updateItem, this, &ParticipantTemplateEditItemTab::updateItem);
+  connect(m_editItemWidget, &ParticipantTemplateEditItemWidget::readyToClose, this, [this]()
+  {
+    m_buttonBox->getButton(LtsWidgets::DialogButton::Close)->click();
+  });
+}
+
+bool ParticipantTemplateEditItemTab::init(const QModelIndex &workingIndex,
+                                          const std::shared_ptr<Interface::Dtc> &dtc,
+                                          const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
+                                          const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
+                                          const TemplateData &data)
+{
+  if (!m_editItemWidget->init(workingIndex, dtc, ppmGuiCbxIfc, asb, data))
+    return false;
+
+  QVBoxLayout *layout = new QVBoxLayout;
+  layout->addWidget(m_editItemWidget);
+  setLayout(layout);
+
+  m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, m_editItemWidget, &ParticipantTemplateEditItemWidget::onEditItem);
+  return true;
+}
+
+void ParticipantTemplateEditItemTab::retranslate()
+{
+  // lupdate doesn't like translate(tr("foo")) ...
+  const QString txt(tr("Participant Item Edit"));
+  translate(txt);
+}
+
+bool ParticipantTemplateEditItemTab::apply()
+{
+  return m_editItemWidget->onEditItem();
+}
+
+} //namespace ParticipantManagement