351 lines
13 KiB
C++
Executable File
351 lines
13 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* MeteoDataManagement - Static Meteo Data Edit Dialog
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by hjl, SLSE, 2016-10-17
|
|
*/
|
|
|
|
#include "esc_firing_explosion.h"
|
|
#include "ui_esc_firing_explosion.h"
|
|
#include "esc_safety_confirmation_widget.h"
|
|
#include "esc_order_edit.h"
|
|
|
|
namespace EffectShowClient
|
|
{
|
|
//=============================================================================
|
|
FiringExplosion::FiringExplosion(QWidget *parent)
|
|
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
|
|
, m_timer(new QTimer(this))
|
|
, m_dtc(nullptr)
|
|
, m_ftc(nullptr)
|
|
, m_session(nullptr)
|
|
, m_safetyConfirmationWidget(nullptr)
|
|
, m_ui(new Ui::FiringExplosion)
|
|
, m_logger(getLogger("FiringExplosion"))
|
|
, m_requestHelper(new LtsUtils::RequestHelper(this))
|
|
, m_idOrder(0)
|
|
, m_idEffectShow(0)
|
|
, m_shotsAvail(0)
|
|
, m_isClearance(true)
|
|
, m_firingClearanceCountDown(0)
|
|
, m_endOfFiringClearanceCountDown(0)
|
|
{
|
|
m_ui->setupUi(this);
|
|
m_ui->pbFire->setEnabled(false);
|
|
connect(m_ui->pbApply, &QPushButton::clicked,
|
|
this, &FiringExplosion::onApply);
|
|
connect(m_ui->pbFire, &QPushButton::clicked,
|
|
this, &FiringExplosion::onFire);
|
|
connect(m_ui->pbInterrupt, &QPushButton::clicked,
|
|
this, &FiringExplosion::onInterrupt);
|
|
connect(m_timer, &QTimer::timeout, this, &FiringExplosion::onFiringClearanceCountDown);
|
|
|
|
// Set a consistent font size for the buttons
|
|
QFont pbFont = m_ui->pbApply->font();
|
|
#ifdef TABLET_MODE
|
|
pbFont.setPointSizeF(pbFont.pointSizeF()*1.5);
|
|
#endif
|
|
m_ui->pbApply->setFont(pbFont);
|
|
m_ui->pbFire->setFont(pbFont);
|
|
m_ui->pbInterrupt->setFont(pbFont);
|
|
|
|
setOnlineHelpFilename(QLatin1String("OC-Firing_Explosive"));
|
|
|
|
}
|
|
//=============================================================================
|
|
FiringExplosion::~FiringExplosion()
|
|
{
|
|
delete m_ui;
|
|
}
|
|
//=============================================================================
|
|
bool FiringExplosion::init(const std::shared_ptr<EffectShowClient::Interface::Dtc> &dtc,
|
|
const std::shared_ptr<EffectShowClient::Interface::Ftc> &ftc,
|
|
LtsSession::LtsSession *session, bool freeForm)
|
|
{
|
|
DEBUG_LOG(m_logger) << "FiringExplosion::init()";
|
|
|
|
if (!dtc || !ftc)
|
|
{
|
|
ERROR_LOG(m_logger) << "FiringExplosion::init() Invalid shared_ptr!";
|
|
return false;
|
|
}
|
|
|
|
m_dtc = dtc;
|
|
m_ftc = ftc;
|
|
m_session = session;
|
|
|
|
m_safetyConfirmationWidget = new SafetyConfirmationWidget(this);
|
|
if (!m_safetyConfirmationWidget->init(m_ftc))
|
|
{
|
|
ERROR_LOG(m_logger) << "Can't create SafetiConfirmationWidget";
|
|
return false;
|
|
}
|
|
m_ui->mainVertLayout->insertWidget(3, m_safetyConfirmationWidget);
|
|
|
|
connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::firingExplosionEntityChanged,
|
|
this, &FiringExplosion::onFiringExplosionEntityChanged);
|
|
connect(m_dtc.get(), &EffectShowClient::Interface::Dtc::operatingConditionEntityChanged,
|
|
this, &FiringExplosion::onOperatingConditionEntityChanged);
|
|
|
|
// display data
|
|
if (!freeForm)
|
|
onFiringExplosionEntityChanged(m_dtc->firingExplosionEntity(), DataModification::eAdded);
|
|
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::No, this, &FiringExplosion::onAbort);
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::No)->setText(tr("Abort"));
|
|
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Yes, this, &FiringExplosion::onCarriedOut);
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::Yes)->setText(tr("Carried Out"));
|
|
|
|
m_ui->sbDuration->setMinimum(5);
|
|
return true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::retranslate()
|
|
{
|
|
translate(m_ui, tr("Firing Explosive")); // todo only "Firing"
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onFiringExplosionEntityChanged(const EffectShowClient::FiringExplosionEntity &data, DataModification modType)
|
|
{
|
|
if (modType == DataModification::eRemoved)
|
|
return; // freeze of indication
|
|
|
|
m_idOrder = data.idOrder();
|
|
m_idEffectShow = data.idEffectShow();
|
|
// if (m_idOrder > 0) \\keep for now
|
|
// m_ui->pbApply->setEnabled(data.fireEnabled() && data.safetyConfirmation() == EffectShowClient::SafetyConfirmation_e::SafetyNotConfirmed);
|
|
|
|
m_ui->pbApply->setEnabled(!data.isActive());
|
|
|
|
OperatingConditionEntity opcon = m_dtc->operatingConditionEntity();
|
|
bool fireUnitsActive = opcon.firingUnitReadyAftLh() || opcon.firingUnitReadyAftRh() || opcon.firingUnitReadyFwdLh() || opcon.firingUnitReadyFwdRh();
|
|
bool pbActiv = (data.fireEnabled() && data.safetyConfirmation() != EffectShowClient::SafetyConfirmation_e::SafetyNotConfirmed);
|
|
|
|
if (!fireUnitsActive && m_safetyConfirmationWidget)
|
|
m_safetyConfirmationWidget->setMessage(tr("Waiting for ready firing unit"));
|
|
else
|
|
m_safetyConfirmationWidget->setMessage(QString());
|
|
|
|
// enable carried out
|
|
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Yes, data.carriedOutEnabled());
|
|
|
|
|
|
if (m_oldEntity.numberOfVolley() != data.numberOfVolley())
|
|
m_ui->sbNumberOfVolley->setValue(data.numberOfVolley());
|
|
if (m_oldEntity.numberOfShot() != data.numberOfShot())
|
|
m_ui->sbNumberOfShot->setValue(data.numberOfShot());
|
|
if (m_oldEntity.duration() != data.duration())
|
|
m_ui->sbDuration->setValue(data.duration() / 1000);
|
|
|
|
if (m_idEffectShow > 0)
|
|
{
|
|
QString textStr = QString::fromStdString(m_dtc->order(m_idEffectShow).info());
|
|
m_ui->leEffectShow->setText(textStr);
|
|
}
|
|
else
|
|
m_ui->leEffectShow->setText(QString());
|
|
|
|
m_timer->stop();
|
|
|
|
m_firingClearanceCountDown = data.firingClearanceTime().is_set() ? (1000 + data.firingClearanceTime().get() - m_session->partitionTime()) : 0;
|
|
m_endOfFiringClearanceCountDown = data.endOfFiringClearanceTime().is_set() ? (1000 + data.endOfFiringClearanceTime().get() - m_session->partitionTime()) : 0;
|
|
|
|
onFiringClearanceCountDown();
|
|
if (data.idOrder() == 0 || (!data.firingClearanceTime().is_set() && data.duration() == 0))
|
|
m_isClearance = true;
|
|
else
|
|
m_isClearance = (m_firingClearanceCountDown <= 0 && m_endOfFiringClearanceCountDown > 0);
|
|
|
|
//enable fire button if show is active, the fire untis are ready and in clearnca time
|
|
m_ui->pbFire->setEnabled(pbActiv && fireUnitsActive && m_isClearance);
|
|
// enale Interrupt
|
|
bool isInterruptEnabled = !data.carriedOutEnabled() && !m_ui->pbFire->isEnabled() && data.isActive() && m_isClearance;
|
|
m_ui->pbInterrupt->setEnabled(isInterruptEnabled);
|
|
|
|
m_ui->leRemainingShots->setText(data.remainingShots() > 0 ? QString::number(data.remainingShots()) : QString::number(0));
|
|
m_ui->leRemainingTime->setText(QString::number(data.remainingTime() / 1000));
|
|
m_ui->leRemainingVolley->setText(data.remainingVolleys() > 0 ? QString::number(data.remainingVolleys()) : QString::number(0));
|
|
m_safetyConfirmation = data.safetyConfirmation();
|
|
onSafetyConfirmationDisplay();
|
|
|
|
m_oldEntity = data;
|
|
}
|
|
|
|
void FiringExplosion::onOperatingConditionEntityChanged(const OperatingConditionEntity &data, DataModification modType)
|
|
{
|
|
Q_UNUSED(modType)
|
|
if (m_safetyConfirmationWidget)
|
|
m_safetyConfirmationWidget->onOperatingConditionEntityChanged(data);
|
|
m_shotsAvail = data.ammunitionMagazine();
|
|
m_ui->lblShotsAvail->setText(QString::number(m_shotsAvail));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onApply()
|
|
{
|
|
if (!statusChangedForManuallyEffectShow(EffectShowStatus_e::Apply))
|
|
ERROR_LOG(m_logger) << "Apply failed";
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onFire()
|
|
{
|
|
bool rc;
|
|
if (m_idOrder > 0)
|
|
rc = statusChangedForOrderedEffectShow(EffectShowStatus_e::Fire);
|
|
else
|
|
rc = statusChangedForManuallyEffectShow(EffectShowStatus_e::Fire);
|
|
|
|
if (!rc)
|
|
ERROR_LOG(m_logger) << "Firing Explosion Order Execution failed";
|
|
}
|
|
void FiringExplosion::onInterrupt()
|
|
{
|
|
bool rc;
|
|
if (m_idOrder > 0)
|
|
rc = statusChangedForOrderedEffectShow(EffectShowStatus_e::Interrupt);
|
|
else
|
|
rc = statusChangedForManuallyEffectShow(EffectShowStatus_e::Interrupt);
|
|
|
|
if (!rc)
|
|
ERROR_LOG(m_logger) << "Firing Explosion Order Execution failed";
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onAbort()
|
|
{
|
|
if (m_idOrder > 0)
|
|
{
|
|
OrderEdit *edit = new OrderEdit(m_dtc->order(m_idEffectShow), false, this);
|
|
edit->init(m_ftc, EffectShowManagement::OrderConfirmation_e::Abort);
|
|
addDialog(edit, menuGroup(), QLatin1String("escOrder"), LtsWidgets::LayoutArea::eDialogTab);
|
|
// rc = statusChangedForOrderedEffectShow(EffectShowStatus_e::Abort);
|
|
return;
|
|
}
|
|
else
|
|
statusChangedForManuallyEffectShow(EffectShowStatus_e::Abort);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onCarriedOut()
|
|
{
|
|
if (m_idOrder > 0)
|
|
{
|
|
OrderEdit *edit = new OrderEdit(m_dtc->order(m_idEffectShow), false, this);
|
|
edit->init(m_ftc, EffectShowManagement::OrderConfirmation_e::OrderCarriedOut);
|
|
addDialog(edit, menuGroup(), QLatin1String("escOrder"), LtsWidgets::LayoutArea::eDialogTab);
|
|
}
|
|
else
|
|
statusChangedForManuallyEffectShow(EffectShowStatus_e::CarriedOut);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onSafetyConfirmationDisplay()
|
|
{
|
|
if (m_safetyConfirmationWidget)
|
|
m_safetyConfirmationWidget->setNewSafetyConfirmationDisplay(m_safetyConfirmation);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void FiringExplosion::onFiringClearanceCountDown()
|
|
{
|
|
if (m_timer->isActive())
|
|
{
|
|
m_firingClearanceCountDown -= 1000;
|
|
m_endOfFiringClearanceCountDown -= 1000;
|
|
}
|
|
|
|
if (m_firingClearanceCountDown > 0)
|
|
m_ui->leFiringClearanceIn->setText(OrderModel::timeOfDayString(m_firingClearanceCountDown / 1000));
|
|
else
|
|
m_ui->leFiringClearanceIn->setText(OrderModel::timeOfDayString(0));
|
|
|
|
if (m_endOfFiringClearanceCountDown > 0)
|
|
m_ui->leEndOfFiringClearanceIn->setText(OrderModel::timeOfDayString(m_endOfFiringClearanceCountDown / 1000));
|
|
else
|
|
m_ui->leEndOfFiringClearanceIn->setText(OrderModel::timeOfDayString(0));
|
|
|
|
if ((m_firingClearanceCountDown > 0) || (m_endOfFiringClearanceCountDown > 0))
|
|
m_timer->start(1000);
|
|
|
|
m_isClearance = (m_firingClearanceCountDown <= 0 && m_endOfFiringClearanceCountDown > 0);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
bool FiringExplosion::statusChangedForManuallyEffectShow(EffectShowStatus_e status)
|
|
{
|
|
m_uiRequirements->clear();
|
|
if (status == EffectShowStatus_e::Apply)
|
|
{
|
|
m_uiRequirements->addRequirement({m_ui->lbShotsAvail, [this]() { return !(m_shotsAvail < m_ui->sbNumberOfShot->value()); }});
|
|
m_uiRequirements->addRequirement({m_ui->lblNumberOfVolley, [this]() { return !(m_ui->sbNumberOfShot->value() < m_ui->sbNumberOfVolley->value()); }});
|
|
m_uiRequirements->addRequirement({m_ui->lblDuration, [this]() { return !(m_ui->sbDuration->value() * 1000 < ((m_ui->sbNumberOfShot->value() * 1000) + (m_ui->sbNumberOfVolley->value() * 2000 ))); }});
|
|
}
|
|
|
|
if (!m_uiRequirements->checkRequirements(this))
|
|
return false; // not all inputs done
|
|
|
|
return m_requestHelper->startSingleRequest([this, status]()
|
|
{
|
|
EffectShowClient::ManuallyExplosionRequest request;
|
|
if (status == EffectShowStatus_e::Interrupt)
|
|
{
|
|
const EffectShowClient::FiringExplosionEntity manEx = m_dtc->firingExplosionEntity();
|
|
|
|
request.numberOfVolley(manEx.remainingVolleys());
|
|
request.numberOfShot(manEx.remainingShots());
|
|
request.duration(manEx.remainingTime());
|
|
}
|
|
else
|
|
{
|
|
request.numberOfVolley(m_ui->sbNumberOfVolley->value());
|
|
request.numberOfShot(m_ui->sbNumberOfShot->value());
|
|
request.duration(m_ui->sbDuration->value() * 1000);
|
|
}
|
|
request.pbFire(status == EffectShowStatus_e::Fire);
|
|
request.pbAbort(status == EffectShowStatus_e::Abort);
|
|
request.pbInterrupt(status == EffectShowStatus_e::Interrupt);
|
|
|
|
request.pbCarriedOut(status == EffectShowStatus_e::CarriedOut || status == EffectShowStatus_e::Abort);
|
|
|
|
return m_ftc->manuallyExplosionRequest(request, this);
|
|
});
|
|
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
bool FiringExplosion::statusChangedForOrderedEffectShow(EffectShowStatus_e status)
|
|
{
|
|
m_uiRequirements->clear();
|
|
|
|
if (!m_uiRequirements->checkRequirements(this))
|
|
return true; // not all inputs done
|
|
|
|
return m_requestHelper->startSingleRequest([this, status]()
|
|
{
|
|
OrderModifyRequest orderModifyRequest;
|
|
|
|
orderModifyRequest.id(m_idEffectShow);
|
|
EffectShowManagement::OrderConfirmation_e oc;
|
|
switch (status)
|
|
{
|
|
case EffectShowStatus_e::Fire:
|
|
oc = EffectShowManagement::OrderConfirmation_e_def::Execution;
|
|
break;
|
|
case EffectShowStatus_e::CarriedOut:
|
|
oc = EffectShowManagement::OrderConfirmation_e_def::OrderCarriedOut;
|
|
break;
|
|
case EffectShowStatus_e::Interrupt:
|
|
oc = EffectShowManagement::OrderConfirmation_e_def::InterruptExecution;
|
|
break;
|
|
default:
|
|
DEBUG_LOG(m_logger) << "FiringExplosion::statusChangedForOrderedEffectShow switch is defaulting, should not happen I guess...";
|
|
break;
|
|
}
|
|
orderModifyRequest.orderConfirmation(oc);
|
|
orderModifyRequest.answerText(QString().toStdString());
|
|
|
|
return m_ftc->orderModifyRequest(orderModifyRequest, this);
|
|
});
|
|
|
|
}
|
|
|
|
|
|
} // namespace EffectShowClient
|