lifemaps/qt-migration-legatus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f74ff251a29d0d365bd79bd7b5d3d50efbbf93d7
qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Plugins/EffectShowClient/Gui/esc_firing_explosion.cpp
T
torstenandCopilot d6b6ffce7c Apply clang-format to Lts/Common and DTC/enum headers 
- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-08-19 14:46:29 +02:00

337 lines
13 KiB
C++
Raw Blame History

#include "esc_firing_explosion.h"
#include "esc_order_edit.h"
#include "esc_safety_confirmation_widget.h"
#include "ui_esc_firing_explosion.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_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);
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);
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"));
}
void FiringExplosion::onFiringExplosionEntityChanged(const EffectShowClient::FiringExplosionEntity& data,
DataModification modType)
{
if (modType == DataModification::eRemoved)
return;
m_idOrder = data.idOrder();
m_idEffectShow = data.idEffectShow();
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());
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);
m_ui->pbFire->setEnabled(pbActiv && fireUnitsActive && m_isClearance);
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);
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;
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;
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
Reference in new issue View Git Blame Copy Permalink