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>
This commit is contained in:
torstenandCopilot committed 2026-08-19 14:46:29 +02:00
1 parent 1881d68aef
commit d6b6ffce7c
848 files changed
+89305 -100020

No files matched your search

@@ -1,252 +1,227 @@
#include "avm_combat_net_radio_dialog.h"
#include "ui_avm_combat_net_radio_dialog.h"
#include "avm_cnr_json_helper.h"
#include "avm_combat_net_radio_dialog_model.h"
#include "avm_edit_combat_net_radio_dialog.h"
#include "avm_cnr_json_helper.h"
#include "avm_load_combat_net_radio_dialog.h"
#include "ui_avm_combat_net_radio_dialog.h"
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsSession/lts_session.h>
#include <LtsPrinting/printing.h>
#include <QTreeView>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <FileManagement/flm_translation.h>
#include <LtsPrinting/printing.h>
#include <LtsSession/lts_session.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <QTreeView>
namespace AudioVideoManagement
{
CombatNetRadioDialog::CombatNetRadioDialog(LtsSession::LtsSession *session, const QString &menuGroup, QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
, m_session(session)
, m_ui(new Ui::CombatNetRadioDialog)
, m_menuGroup(menuGroup)
, m_requestHelper(new LtsUtils::RequestHelper(this))
CombatNetRadioDialog::CombatNetRadioDialog(LtsSession::LtsSession* session, const QString& menuGroup, QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly), m_session(session),
m_ui(new Ui::CombatNetRadioDialog), m_menuGroup(menuGroup), m_requestHelper(new LtsUtils::RequestHelper(this))
{
m_ui->setupUi(this);
setUnchangeable(true);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &CombatNetRadioDialog::onPrint);
m_ui->setupUi(this);
setUnchangeable(true);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &CombatNetRadioDialog::onPrint);
setOnlineHelpFilename(QStringLiteral("Situation-Combat_Net_Radio_Configuration"));
setOnlineHelpFilename(QStringLiteral("Situation-Combat_Net_Radio_Configuration"));
}
CombatNetRadioDialog::~CombatNetRadioDialog() = default;
void CombatNetRadioDialog::retranslate()
{
translate(m_ui.get(), tr("Configure Combat Net Radio"));
translate(m_ui.get(), tr("Configure Combat Net Radio"));
}
void CombatNetRadioDialog::tableColumnOrganiserSetting()
{
m_ui->dataView->setColumnsOrganiserEnabled(identifier(), true);
m_ui->dataView->setColumnsOrganiserEnabled(identifier(), true);
}
bool CombatNetRadioDialog::init(const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
ExerciseManagement::Interface::Dtc *exmDtc)
bool CombatNetRadioDialog::init(const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<Interface::Ftc>& avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
ExerciseManagement::Interface::Dtc* exmDtc)
{
if (!(avmDtc->enableCnrChannel() &&
avmDtc->enableCnrConfig() &&
ppmDtc->enableParty() &&
ppmDtc->enableParticipant() &&
ppmDtc->enableType() &&
avmFtc->enableModifyCnrConfig() &&
avmFtc->enableRemoveCnrConfig()))
{
ERROR_LOG(m_logger) << "Could not enable topics";
return false;
}
if (!(avmDtc->enableCnrChannel() && avmDtc->enableCnrConfig() && ppmDtc->enableParty() &&
ppmDtc->enableParticipant() && ppmDtc->enableType() && avmFtc->enableModifyCnrConfig() &&
avmFtc->enableRemoveCnrConfig()))
{
ERROR_LOG(m_logger) << "Could not enable topics";
return false;
}
m_model.reset(new CombatNetRadioDialogModel(m_session->exerciseId(), this));
m_filter.reset(new CombatNetRadioDialogFilter(m_session->exerciseId(), m_model.get()));
m_model.reset(new CombatNetRadioDialogModel(m_session->exerciseId(), this));
m_filter.reset(new CombatNetRadioDialogFilter(m_session->exerciseId(), m_model.get()));
m_avmDtc = avmDtc;
m_avmFtc = avmFtc;
m_ppmDtc = ppmDtc;
m_exmDtc = exmDtc;
m_avmDtc = avmDtc;
m_avmFtc = avmFtc;
m_ppmDtc = ppmDtc;
m_exmDtc = exmDtc;
m_avmDtc->waitForHistoricalDataCnrChannel(3000);
m_ppmDtc->waitForHistoricalDataParty(3000);
m_avmDtc->waitForHistoricalDataCnrChannel(3000);
m_ppmDtc->waitForHistoricalDataParty(3000);
if (!m_model->init(avmDtc, ppmDtc))
{
m_filter.reset();
m_model.reset();
ERROR_LOG(m_logger) << "Could not init model";
return false;
}
if (!m_model->init(avmDtc, ppmDtc))
{
m_filter.reset();
m_model.reset();
ERROR_LOG(m_logger) << "Could not init model";
return false;
}
m_ui->dataView->setModel(m_filter.get());
m_ui->dataView->setModel(m_filter.get());
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &CombatNetRadioDialog::onAddClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &CombatNetRadioDialog::onEditClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &CombatNetRadioDialog::onRemoveClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &CombatNetRadioDialog::onAddClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &CombatNetRadioDialog::onEditClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &CombatNetRadioDialog::onRemoveClicked);
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalSelectionChanged,
this, &CombatNetRadioDialog::onSelectionChanged);
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalSelectionChanged, this,
&CombatNetRadioDialog::onSelectionChanged);
onSelectionChanged();
onSelectionChanged();
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalDoubleClicked,
this, &CombatNetRadioDialog::onEditClicked);
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalDoubleClicked, this, &CombatNetRadioDialog::onEditClicked);
m_buttonBox->connectLibraryButton(this,
&CombatNetRadioDialog::onImportButtonClicked,
&CombatNetRadioDialog::onExportButtonClicked);
m_buttonBox->connectLibraryButton(this, &CombatNetRadioDialog::onImportButtonClicked,
&CombatNetRadioDialog::onExportButtonClicked);
if (!m_session->getForeignGuiInterface<FileManagement::ForeignGuiInterface>(m_flmGui))
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Library, false);
if (!m_session->getForeignGuiInterface<FileManagement::ForeignGuiInterface>(m_flmGui))
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Library, false);
return true;
return true;
}
void CombatNetRadioDialog::onRemoveCnrConfigReply(const Core::FunctionReplyObject &replyObject)
void CombatNetRadioDialog::onRemoveCnrConfigReply(const Core::FunctionReplyObject& replyObject)
{
m_requestHelper->requestReply(replyObject);
m_requestHelper->requestReply(replyObject);
}
void CombatNetRadioDialog::onModifyCnrConfigReply(const Core::FunctionReplyObject &replyObject)
void CombatNetRadioDialog::onModifyCnrConfigReply(const Core::FunctionReplyObject& replyObject)
{
m_requestHelper->requestReply(replyObject);
m_requestHelper->requestReply(replyObject);
}
void CombatNetRadioDialog::onAddClicked()
{
EditCombatNetRadioDialog *dialog = new EditCombatNetRadioDialog(m_session->exerciseId(), m_session, m_ppmDtc, m_avmDtc, m_avmFtc, m_exmDtc, this);
addDialog(dialog, m_menuGroup, QStringLiteral("NewCNRConfig"), LtsWidgets::LayoutArea::eDialogTab);
EditCombatNetRadioDialog* dialog =
new EditCombatNetRadioDialog(m_session->exerciseId(), m_session, m_ppmDtc, m_avmDtc, m_avmFtc, m_exmDtc, this);
addDialog(dialog, m_menuGroup, QStringLiteral("NewCNRConfig"), LtsWidgets::LayoutArea::eDialogTab);
}
void CombatNetRadioDialog::onEditClicked()
{
if (!m_buttonBox->isButtonEnabled(LtsWidgets::DialogButton::Edit))
return;
QModelIndex currentIndex = m_ui->dataView->currentIndex();
if (!m_buttonBox->isButtonEnabled(LtsWidgets::DialogButton::Edit))
return;
if (!currentIndex.isValid())
return;
QModelIndex currentIndex = m_ui->dataView->currentIndex();
CnrConfig config = m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>();
if (!currentIndex.isValid())
return;
EditCombatNetRadioDialog *dialog = new EditCombatNetRadioDialog(config,
m_session->exerciseId(),
m_session,
m_ppmDtc,
m_avmDtc,
m_avmFtc,
m_exmDtc,
this);
CnrConfig config = m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>();
addDialog(dialog, m_menuGroup, QStringLiteral("EditCNRConfig%1").arg(config.id()), LtsWidgets::LayoutArea::eDialogTab);
EditCombatNetRadioDialog* dialog = new EditCombatNetRadioDialog(config, m_session->exerciseId(), m_session,
m_ppmDtc, m_avmDtc, m_avmFtc, m_exmDtc, this);
addDialog(dialog, m_menuGroup, QStringLiteral("EditCNRConfig%1").arg(config.id()),
LtsWidgets::LayoutArea::eDialogTab);
}
void CombatNetRadioDialog::onRemoveClicked()
{
QModelIndex currentIndex = m_ui->dataView->currentIndex();
QModelIndex currentIndex = m_ui->dataView->currentIndex();
if (!currentIndex.isValid())
return;
if (!currentIndex.isValid())
return;
Core::RemoveElementRequest request(m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>().id());
Core::RemoveElementRequest request(m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>().id());
m_requestHelper->startSingleRequest([this, request]()
{
return m_avmFtc->removeCnrConfigRequest(request, this);
});
m_requestHelper->startSingleRequest([this, request]() { return m_avmFtc->removeCnrConfigRequest(request, this); });
}
void CombatNetRadioDialog::onSelectionChanged()
{
bool rowSelected = m_ui->dataView->selectionModel()->selectedRows().size() > 0;
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, rowSelected);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, rowSelected);
bool rowSelected = m_ui->dataView->selectionModel()->selectedRows().size() > 0;
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, rowSelected);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, rowSelected);
QModelIndex currentIndex = m_ui->dataView->currentIndex();
QModelIndex currentIndex = m_ui->dataView->currentIndex();
if (!currentIndex.isValid())
return;
if (!currentIndex.isValid())
return;
CnrConfig config = m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>();
bool enabled = rowSelected && (config.exerciseId().is_set() || m_session->partitionType() == IDL::PartitionType::Global);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, enabled);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, enabled);
CnrConfig config = m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>();
bool enabled =
rowSelected && (config.exerciseId().is_set() || m_session->partitionType() == IDL::PartitionType::Global);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, enabled);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, enabled);
}
void CombatNetRadioDialog::onPrint()
{
LtsPrinting::printView(m_session, this, m_ui->dataView->treeView());
LtsPrinting::printView(m_session, this, m_ui->dataView->treeView());
}
void CombatNetRadioDialog::onExportButtonClicked()
{
QByteArray byteArray = m_filter->modelToJson();
QByteArray byteArray = m_filter->modelToJson();
int fileId = m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
if (fileId > 0)
DEBUG_LOG(m_logger) << "Saved file with id = " << fileId;
else
ERROR_LOG(m_logger) << "Could not save file in library ";
int fileId = m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
if (fileId > 0)
DEBUG_LOG(m_logger) << "Saved file with id = " << fileId;
else
ERROR_LOG(m_logger) << "Could not save file in library ";
}
void CombatNetRadioDialog::onImportButtonClicked()
{
DEBUG_LOG(m_logger) << " onImportButtonClicked() ";
DEBUG_LOG(m_logger) << " onImportButtonClicked() ";
QByteArray content;
int fileId = m_flmGui->loadFileContent(this, content, {FileManagement::FileType::Xml}, m_session->exerciseId(), FileManagement::toString(FileManagement::XmlType::AVMCombatNetRadio));
QByteArray content;
int fileId = m_flmGui->loadFileContent(this, content, {FileManagement::FileType::Xml}, m_session->exerciseId(),
FileManagement::toString(FileManagement::XmlType::AVMCombatNetRadio));
if (fileId > 0)
{
if (!m_flmGui->isXmlType(content, FileManagement::toString(FileManagement::XmlType::AVMCombatNetRadio)))
if (fileId > 0)
{
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this,
tr("Invalid xml file content"),
windowTitle(),
LtsWidgets::Behaviour::Modal,
LtsWidgets::Button::Yes,
texts);
}
else
{
LoadCombatNetRadioDialog loadingDialog(content, m_session) ;
loadingDialog.exec();
if (loadingDialog.isApplied())
{
const QVector<Core::RemoveElementRequest> removeRequests = loadingDialog.removeRequests();
for (const auto &removeRequest : removeRequests)
if (!m_flmGui->isXmlType(content, FileManagement::toString(FileManagement::XmlType::AVMCombatNetRadio)))
{
m_requestHelper->addRequest([this, removeRequest]()
{
return m_avmFtc->removeCnrConfigRequest(removeRequest, this);
});
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Invalid xml file content"), windowTitle(),
LtsWidgets::Behaviour::Modal, LtsWidgets::Button::Yes, texts);
}
const QVector<ModifyCnrConfigRequest> modifyRequests = loadingDialog.modifyRequests();
for (const auto &modifyRequest : modifyRequests)
else
{
m_requestHelper->addRequest([this, modifyRequest]()
{
return m_avmFtc->modifyCnrConfigRequest(modifyRequest, this);
});
}
LoadCombatNetRadioDialog loadingDialog(content, m_session);
loadingDialog.exec();
if (modifyRequests.size() || removeRequests.size())
(void) m_requestHelper->startRequests();
}
if (loadingDialog.isApplied())
{
const QVector<Core::RemoveElementRequest> removeRequests = loadingDialog.removeRequests();
for (const auto& removeRequest : removeRequests)
{
m_requestHelper->addRequest(
[this, removeRequest]() { return m_avmFtc->removeCnrConfigRequest(removeRequest, this); });
}
const QVector<ModifyCnrConfigRequest> modifyRequests = loadingDialog.modifyRequests();
for (const auto& modifyRequest : modifyRequests)
{
m_requestHelper->addRequest(
[this, modifyRequest]() { return m_avmFtc->modifyCnrConfigRequest(modifyRequest, this); });
}
if (modifyRequests.size() || removeRequests.size())
(void)m_requestHelper->startRequests();
}
}
}
}
}
}
} // namespace AudioVideoManagement
@@ -1,14 +1,11 @@
#pragma once
#include <LtsWidgets/lts_dialog.h>
#include <AudioVideoManagement/logger.h>
#include <AudioVideoManagement/avm_ftc.h>
#include <AudioVideoManagement/logger.h>
#include <LtsWidgets/lts_dialog.h>
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
#include <memory>
namespace Ui
@@ -27,7 +24,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace AudioVideoManagement
namespace ParticipantManagement
{
@@ -35,7 +32,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ParticipantManagement
namespace ExerciseManagement
{
@@ -43,58 +40,59 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace LtsSession
{
class LtsSession;
}
namespace AudioVideoManagement
{
class CombatNetRadioDialogModel;
class CombatNetRadioDialogFilter;
class CombatNetRadioDialog
: public LtsWidgets::LtsDialog
, protected Interface::Ftc::RemoveCnrConfigReplyHandler
, protected Interface::Ftc::ModifyCnrConfigReplyHandler
class CombatNetRadioDialog : public LtsWidgets::LtsDialog,
protected Interface::Ftc::RemoveCnrConfigReplyHandler,
protected Interface::Ftc::ModifyCnrConfigReplyHandler
{
Q_OBJECT
public:
explicit CombatNetRadioDialog(LtsSession::LtsSession *session, const QString &menuGroup, QWidget *parent = nullptr);
~CombatNetRadioDialog();
Q_OBJECT
public:
explicit CombatNetRadioDialog(LtsSession::LtsSession* session, const QString& menuGroup, QWidget* parent = nullptr);
~CombatNetRadioDialog();
bool init(const std::shared_ptr<Interface::Dtc> &avmDtc, const std::shared_ptr<Interface::Ftc> &avmFtc, const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc, ExerciseManagement::Interface::Dtc *exmDtc);
bool init(const std::shared_ptr<Interface::Dtc>& avmDtc, const std::shared_ptr<Interface::Ftc>& avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
ExerciseManagement::Interface::Dtc* exmDtc);
void onRemoveCnrConfigReply(const Core::FunctionReplyObject &replyObject) override final;
void onModifyCnrConfigReply(const Core::FunctionReplyObject &replyObject) override final;
void onRemoveCnrConfigReply(const Core::FunctionReplyObject& replyObject) override final;
void onModifyCnrConfigReply(const Core::FunctionReplyObject& replyObject) override final;
private Q_SLOTS:
void onAddClicked();
void onEditClicked();
void onRemoveClicked();
void onSelectionChanged();
void onPrint();
void onExportButtonClicked();
void onImportButtonClicked();
private Q_SLOTS:
void onAddClicked();
void onEditClicked();
void onRemoveClicked();
void onSelectionChanged();
void onPrint();
void onExportButtonClicked();
void onImportButtonClicked();
private:
private:
NGL::INGLLogger& m_logger;
void retranslate() override;
void tableColumnOrganiserSetting() override;
NGL::INGLLogger &m_logger;
void retranslate() override;
void tableColumnOrganiserSetting() override;
private:
LtsSession::LtsSession *m_session;
std::unique_ptr<CombatNetRadioDialogModel> m_model;
std::unique_ptr<CombatNetRadioDialogFilter> m_filter;
std::unique_ptr<Ui::CombatNetRadioDialog> m_ui;
QString m_menuGroup;
std::unique_ptr<LtsUtils::RequestHelper> m_requestHelper;
std::shared_ptr<Interface::Dtc> m_avmDtc;
std::shared_ptr<Interface::Ftc> m_avmFtc;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
ExerciseManagement::Interface::Dtc *m_exmDtc{nullptr};
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
};
}
private:
LtsSession::LtsSession* m_session;
std::unique_ptr<CombatNetRadioDialogModel> m_model;
std::unique_ptr<CombatNetRadioDialogFilter> m_filter;
std::unique_ptr<Ui::CombatNetRadioDialog> m_ui;
QString m_menuGroup;
std::unique_ptr<LtsUtils::RequestHelper> m_requestHelper;
std::shared_ptr<Interface::Dtc> m_avmDtc;
std::shared_ptr<Interface::Ftc> m_avmFtc;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
ExerciseManagement::Interface::Dtc* m_exmDtc{nullptr};
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
};
} // namespace AudioVideoManagement
@@ -1,153 +1,145 @@
#include "avm_combat_net_radio_dialog_model.h"
#include <utility>
#include <ParticipantManagement/ppm_translation.h>
#include <LtsSession/lts_session_data.h>
#include <AudioVideoManagement/avm_ftc.h>
#include "avm_cnr_json_helper.h"
#include <AudioVideoManagement/avm_ftc.h>
#include <LtsSession/lts_session_data.h>
#include <ParticipantManagement/ppm_translation.h>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QJsonObject>
#include <utility>
namespace AudioVideoManagement
{
CombatNetRadioDialogModel::CombatNetRadioDialogModel(int32_t exerciseId, QObject *parent)
: LtsAbstractTableModel<CnrConfig>(
{
tr("Channel Number"),
tr("Radio Circuit"),
tr("Code Word"),
tr("Party"),
tr("Unit"),
tr("Global")
}, parent)
, m_exerciseId(exerciseId)
CombatNetRadioDialogModel::CombatNetRadioDialogModel(int32_t exerciseId, QObject* parent)
: LtsAbstractTableModel<CnrConfig>(
{tr("Channel Number"), tr("Radio Circuit"), tr("Code Word"), tr("Party"), tr("Unit"), tr("Global")}, parent),
m_exerciseId(exerciseId)
{
}
QVariant CombatNetRadioDialogModel::data(const QModelIndex &index, int role) const
QVariant CombatNetRadioDialogModel::data(const QModelIndex& index, int role) const
{
if ((role != Qt::BackgroundRole &&role != Qt::DisplayRole && role != Qt::UserRole) || !indexIsValid(index))
if ((role != Qt::BackgroundRole && role != Qt::DisplayRole && role != Qt::UserRole) || !indexIsValid(index))
return {};
const CnrConfig& config = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
switch (index.column())
{
case CHANNEL:
INFO_LOG(m_logger) << "CombatNetRadioDialogModel::data role =" << role << " row = " << index.row();
return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId()).name());
case RADIO_CIRCUIT:
return QString::fromStdString(config.radioCircuit());
case CALL_SIGN:
return QString::fromStdString(config.callSign());
case PARTY:
if (config.exerciseId().is_set() || config.partyId() > 0)
return ParticipantManagement::trPartyName(m_parties.value(config.partyId()).name());
else
return QStringLiteral("-");
case UNIT: {
if (!config.unitId().is_set())
return {};
const int unitId = config.unitId().get();
const auto unit = m_units.value(config.unitId().get());
if (unit.id() != unitId)
return {};
INFO_LOG(m_logger) << " config.unitId()=" << unitId << " Str=" << unit.name();
QString unitStr;
if (unit.designator().size() > 0)
unitStr = QString::fromStdString(unit.designator()) + QLatin1Char('/');
unitStr.append(QString::fromStdString(unit.tacticalIdentifier()));
INFO_LOG(m_logger) << "unitStr = " << unitStr;
return unitStr;
}
case GLOBAL:
return config.exerciseId().is_set() ? tr("No") : tr("Yes");
}
}
else if (role == Qt::BackgroundRole)
{
if (config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId)
return {};
if (!config.exerciseId().is_set() && m_exerciseId <= 0)
return {};
return QColor(Qt::gray);
}
else if (role == Qt::UserRole)
return QVariant::fromValue(config);
return {};
const CnrConfig &config = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
switch (index.column())
{
case CHANNEL:
INFO_LOG(m_logger)<<"CombatNetRadioDialogModel::data role =" << role
<< " row = " << index.row();
return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId()).name());
case RADIO_CIRCUIT:
return QString::fromStdString(config.radioCircuit());
case CALL_SIGN:
return QString::fromStdString(config.callSign());
case PARTY:
if(config.exerciseId().is_set() || config.partyId() > 0)
return ParticipantManagement::trPartyName(m_parties.value(config.partyId()).name());
else
return QStringLiteral("-");
case UNIT:
{
if (!config.unitId().is_set())
return {};
const int unitId = config.unitId().get();
const auto unit = m_units.value(config.unitId().get());
if (unit.id() != unitId)
return {};
INFO_LOG(m_logger) << " config.unitId()=" << unitId
<< " Str=" << unit.name();
QString unitStr;
if (unit.designator().size() > 0)
unitStr = QString::fromStdString(unit.designator()) + QLatin1Char('/');
unitStr.append(QString::fromStdString(unit.tacticalIdentifier()));
INFO_LOG(m_logger) << "unitStr = " << unitStr;
return unitStr;
}
case GLOBAL:
return config.exerciseId().is_set() ? tr("No") : tr("Yes");
}
}
else if (role == Qt::BackgroundRole)
{
if (config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId)
return {};
if (!config.exerciseId().is_set() && m_exerciseId <= 0)
return {};
return QColor(Qt::gray);
}
else if (role == Qt::UserRole)
return QVariant::fromValue(config);
return {};
}
bool CombatNetRadioDialogModel::init(const std::shared_ptr<Interface::Dtc> &avmDtc, const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc)
bool CombatNetRadioDialogModel::init(const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc)
{
m_avmDtc = avmDtc;
m_avmDtc = avmDtc;
m_cnrChannels = avmDtc->cnrChannels();
m_cnrChannels = avmDtc->cnrChannels();
if (!ppmDtc->visibleParties(m_parties, LtsSessionData::LtsSessionData::getInstance()->getVisibleParties(m_exerciseId)))
{
ERROR_LOG(m_logger) << "Could not retrieve visible Parties!";
return false;
}
m_units = ppmDtc->units();
if (!ppmDtc->visibleParties(m_parties,
LtsSessionData::LtsSessionData::getInstance()->getVisibleParties(m_exerciseId)))
{
ERROR_LOG(m_logger) << "Could not retrieve visible Parties!";
return false;
}
m_units = ppmDtc->units();
connect(m_avmDtc.get(), &Interface::Dtc::cnrConfigChanged, this, &CombatNetRadioDialogModel::onDataChanged);
m_avmDtc->cnrConfigs([this](const CnrConfig &c) { insertRow(c); });
connect(m_avmDtc.get(), &Interface::Dtc::cnrConfigChanged, this, &CombatNetRadioDialogModel::onDataChanged);
m_avmDtc->cnrConfigs([this](const CnrConfig& c) { insertRow(c); });
return true;
return true;
}
bool CombatNetRadioDialogModel::onlyGlobals()
{
for(const CnrConfig &config : std::as_const(m_vecData))
{
if(config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId)
return false;
}
return true;
for (const CnrConfig& config : std::as_const(m_vecData))
{
if (config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId)
return false;
}
return true;
}
QByteArray CombatNetRadioDialogFilter::modelToJson() const
{
QVector<CnrConfig> configs;
configs.reserve(rowCount());
QVector<CnrConfig> configs;
configs.reserve(rowCount());
for (int row = 0; row < rowCount(); ++row)
{
int sourceRow = mapToSource(index(row, 0)).row();
configs.append(m_sourceModel->getRowData(sourceRow));
}
for (int row = 0; row < rowCount(); ++row)
{
int sourceRow = mapToSource(index(row, 0)).row();
configs.append(m_sourceModel->getRowData(sourceRow));
}
return cnrConfigVectorToJson(configs, m_exerciseId);
return cnrConfigVectorToJson(configs, m_exerciseId);
}
CombatNetRadioDialogFilter::CombatNetRadioDialogFilter(int32_t exerciseId, CombatNetRadioDialogModel *sourceModel)
: m_exerciseId(exerciseId)
, m_sourceModel(sourceModel)
CombatNetRadioDialogFilter::CombatNetRadioDialogFilter(int32_t exerciseId, CombatNetRadioDialogModel* sourceModel)
: m_exerciseId(exerciseId), m_sourceModel(sourceModel)
{
Q_ASSERT(sourceModel);
setSourceModel(sourceModel);
Q_ASSERT(sourceModel);
setSourceModel(sourceModel);
}
bool CombatNetRadioDialogFilter::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
bool CombatNetRadioDialogFilter::filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const
{
CnrConfig cnrConfig = m_sourceModel->getRowData(sourceRow);
CnrConfig cnrConfig = m_sourceModel->getRowData(sourceRow);
if (cnrConfig.exerciseId().is_set() && cnrConfig.exerciseId().get() != m_exerciseId)
return false;
if (cnrConfig.exerciseId().is_set() && cnrConfig.exerciseId().get() != m_exerciseId)
return false;
return LtsColumnFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);
return LtsColumnFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);
}
}
} // namespace AudioVideoManagement
@@ -1,77 +1,60 @@
#pragma once
#include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/logger.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
#include <AudioVideoManagement/logger.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <ParticipantManagement/ppm.hpp>
#include <memory>
#include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
#include <cstdint>
#include <memory>
namespace AudioVideoManagement
{
class CombatNetRadioDialogModel final
: public LtsWidgets::LtsAbstractTableModel<CnrConfig>
class CombatNetRadioDialogModel final : public LtsWidgets::LtsAbstractTableModel<CnrConfig>
{
Q_OBJECT
Q_OBJECT
public:
enum Columns
{
CHANNEL,
RADIO_CIRCUIT,
CALL_SIGN,
PARTY,
UNIT,
GLOBAL
};
public:
enum Columns { CHANNEL, RADIO_CIRCUIT, CALL_SIGN, PARTY, UNIT, GLOBAL };
explicit CombatNetRadioDialogModel(int32_t exerciseId, QObject *parent = nullptr);
explicit CombatNetRadioDialogModel(int32_t exerciseId, QObject* parent = nullptr);
QVariant data(const QModelIndex &index, int role) const override;
bool init(const std::shared_ptr<Interface::Dtc> &avmDtc, const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc);
bool onlyGlobals();
QVariant data(const QModelIndex& index, int role) const override;
bool init(const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc);
bool onlyGlobals();
private:
NGL::INGLLogger &m_logger;
std::shared_ptr<Interface::Dtc> m_avmDtc;
int32_t m_exerciseId;
QMap<int32_t, CnrChannel> m_cnrChannels;
QMap<int32_t, ParticipantManagement::Party> m_parties;
QMap<int32_t, ParticipantManagement::Participant> m_units;
private:
NGL::INGLLogger& m_logger;
std::shared_ptr<Interface::Dtc> m_avmDtc;
int32_t m_exerciseId;
QMap<int32_t, CnrChannel> m_cnrChannels;
QMap<int32_t, ParticipantManagement::Party> m_parties;
QMap<int32_t, ParticipantManagement::Participant> m_units;
};
class CombatNetRadioDialogFilter : public LtsWidgets::LtsColumnFilterProxyModel
{
public:
explicit CombatNetRadioDialogFilter(int32_t exerciseId, CombatNetRadioDialogModel *sourceModel);
public:
explicit CombatNetRadioDialogFilter(int32_t exerciseId, CombatNetRadioDialogModel* sourceModel);
QByteArray modelToJson() const;
QByteArray modelToJson() const;
protected:
bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
protected:
bool filterAcceptsRow(int sourceRow, const QModelIndex& sourceParent) const override;
private:
using LtsWidgets::LtsColumnFilterProxyModel::setSourceModel;
private:
using LtsWidgets::LtsColumnFilterProxyModel::setSourceModel;
int32_t m_exerciseId;
CombatNetRadioDialogModel *m_sourceModel;
int32_t m_exerciseId;
CombatNetRadioDialogModel* m_sourceModel;
};
}
} // namespace AudioVideoManagement
Q_DECLARE_METATYPE(AudioVideoManagement::CnrConfig)
Q_DECLARE_METATYPE(AudioVideoManagement::FrequencyPlanningData)
@@ -1,19 +1,17 @@
#pragma once
#include <LtsWidgets/lts_dialog.h>
#include <AudioVideoManagement/logger.h>
#include <ParticipantManagement/ppm.hpp>
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/avm_ftc.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <AudioVideoManagement/logger.h>
#include <LtsSession/lts_session.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsWidgets/lts_dialog.h>
#include <ParticipantManagement/ppm.hpp>
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
#include <QVector>
#include <QString>
#include <QVector>
#include <boost/optional.hpp>
#include <memory>
@@ -25,7 +23,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace Ui
{
@@ -34,90 +32,78 @@ class EditCombatNetRadioDialog;
namespace AudioVideoManagement
{
class EditCombatNetRadioDialog
: public LtsWidgets::LtsDialog
, protected Interface::Ftc::ModifyCnrConfigReplyHandler
class EditCombatNetRadioDialog : public LtsWidgets::LtsDialog, protected Interface::Ftc::ModifyCnrConfigReplyHandler
{
Q_OBJECT
public:
Q_OBJECT
public:
explicit EditCombatNetRadioDialog(int32_t exerciseId, LtsSession::LtsSession* session,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<Interface::Ftc>& avmFtc,
ExerciseManagement::Interface::Dtc* exmDtc, QWidget* parent);
explicit EditCombatNetRadioDialog(int32_t exerciseId,
LtsSession::LtsSession *session,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
ExerciseManagement::Interface::Dtc *exmDtc,
QWidget *parent);
explicit EditCombatNetRadioDialog(const CnrConfig& cnrConfig, int32_t exerciseId, LtsSession::LtsSession* session,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<Interface::Ftc>& avmFtc,
ExerciseManagement::Interface::Dtc* exmDtc, QWidget* parent);
~EditCombatNetRadioDialog();
explicit EditCombatNetRadioDialog(const CnrConfig &cnrConfig,
int32_t exerciseId,
LtsSession::LtsSession *session,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
ExerciseManagement::Interface::Dtc *exmDtc,
QWidget *parent);
void retranslate() override;
~EditCombatNetRadioDialog();
void onModifyCnrConfigReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
void retranslate() override;
protected:
NGL::INGLLogger& m_logger;
bool apply() override;
void onModifyCnrConfigReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
private:
EditCombatNetRadioDialog(const boost::optional<int32_t>& id, int32_t exerciseId, LtsSession::LtsSession* session,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<Interface::Ftc>& avmFtc, ExerciseManagement::Interface::Dtc* exmDtc,
QWidget* parent);
protected:
void init(LtsSession::LtsSession* session);
NGL::INGLLogger &m_logger;
bool apply() override;
void initCbChannelsForCreate();
void initCbChannels(int channelId);
void updateFreeChannelsAndTakenNames();
void updateCbChannels(QVector<int>&& freeChannels, QMap<int, QString>&& channelsToDisable);
QVector<int> exercisesToConsider() const;
QVector<int> exercisesToIgnore() const;
bool isNameValid(const QString& name) const;
private:
EditCombatNetRadioDialog(const boost::optional<int32_t> &id,
int32_t exerciseId,
LtsSession::LtsSession *session,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
ExerciseManagement::Interface::Dtc *exmDtc,
QWidget *parent);
QByteArray cnrConfigRequestToJson();
ModifyCnrConfigRequest createRequest();
ModifyCnrConfigRequest jsonToModifyCnrConfig(const QByteArray& content);
void setUiValues(const CnrConfig& cnrConfig);
void setUiValuesForGlobal();
void init(LtsSession::LtsSession *session);
private Q_SLOTS:
void onPartyIndexChanged(int index);
void onExportButtonClicked();
void onImportButtonClicked();
void onChannelChanged(int index);
void initCbChannelsForCreate();
void initCbChannels(int channelId);
void updateFreeChannelsAndTakenNames();
void updateCbChannels(QVector<int> &&freeChannels, QMap<int, QString> &&channelsToDisable);
QVector<int> exercisesToConsider() const;
QVector<int> exercisesToIgnore() const;
bool isNameValid(const QString &name) const;
QByteArray cnrConfigRequestToJson();
ModifyCnrConfigRequest createRequest();
ModifyCnrConfigRequest jsonToModifyCnrConfig(const QByteArray &content);
void setUiValues(const CnrConfig &cnrConfig);
void setUiValuesForGlobal();
private Q_SLOTS:
void onPartyIndexChanged(int index);
void onExportButtonClicked();
void onImportButtonClicked();
void onChannelChanged(int index);
private:
std::unique_ptr<Ui::EditCombatNetRadioDialog> m_ui;
boost::optional<int32_t> m_id;
int32_t m_exerciseId;
boost::optional<int32_t> m_channelId;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
std::shared_ptr<Interface::Dtc> m_avmDtc;
std::shared_ptr<Interface::Ftc> m_avmFtc;
ExerciseManagement::Interface::Dtc *m_exmDtc;
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
QMap<int32_t, ParticipantManagement::Participant> m_units;
QVector<QString> m_takenNames;
std::unique_ptr<LtsUtils::RequestHelper> m_requestHelper;
bool m_isGlobal;
};
}
private:
std::unique_ptr<Ui::EditCombatNetRadioDialog> m_ui;
boost::optional<int32_t> m_id;
int32_t m_exerciseId;
boost::optional<int32_t> m_channelId;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
std::shared_ptr<Interface::Dtc> m_avmDtc;
std::shared_ptr<Interface::Ftc> m_avmFtc;
ExerciseManagement::Interface::Dtc* m_exmDtc;
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
QMap<int32_t, ParticipantManagement::Participant> m_units;
QVector<QString> m_takenNames;
std::unique_ptr<LtsUtils::RequestHelper> m_requestHelper;
bool m_isGlobal;
};
} // namespace AudioVideoManagement
@@ -1,11 +1,10 @@
#pragma once
#include <LtsWidgets/lts_frameless_dialog.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/logger.h>
#include <LtsWidgets/lts_frameless_dialog.h>
namespace Ui
{
@@ -23,7 +22,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ParticipantManagement
namespace ExerciseManagement
{
@@ -31,36 +30,33 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace AudioVideoManagement
{
class LoadCombatNetRadioDialogModel;
class LoadCombatNetRadioDialog
: public LtsWidgets::LtsFramelessDialog
class LoadCombatNetRadioDialog : public LtsWidgets::LtsFramelessDialog
{
Q_OBJECT
public:
explicit LoadCombatNetRadioDialog(const QByteArray &data,
LtsSession::LtsSession *session,
QWidget *parent = nullptr);
Q_OBJECT
public:
explicit LoadCombatNetRadioDialog(const QByteArray& data, LtsSession::LtsSession* session,
QWidget* parent = nullptr);
~LoadCombatNetRadioDialog();
~LoadCombatNetRadioDialog();
QVector<Core::RemoveElementRequest> removeRequests() const;
QVector<ModifyCnrConfigRequest> modifyRequests() const;
QVector<Core::RemoveElementRequest> removeRequests() const;
QVector<ModifyCnrConfigRequest> modifyRequests() const;
bool isApplied() const;
bool isApplied() const;
private Q_SLOTS:
void onOk();
private Q_SLOTS:
void onOk();
private:
NGL::INGLLogger &m_logger;
std::unique_ptr<Ui::LoadCombatNetRadioDialog> m_ui;
LoadCombatNetRadioDialogModel *m_model;
bool m_isApplied = false;
};
}
private:
NGL::INGLLogger& m_logger;
std::unique_ptr<Ui::LoadCombatNetRadioDialog> m_ui;
LoadCombatNetRadioDialogModel* m_model;
bool m_isApplied = false;
};
} // namespace AudioVideoManagement
@@ -1,427 +1,412 @@
#include "avm_load_combat_net_radio_dialog_model.h"
#include <ParticipantManagement/ppm_translation.h>
#include <LtsSession/lts_session_data.h>
#include <AudioVideoManagement/avm_ftc.h>
#include <Core/core.hpp>
#include <FileManagement/flm_translation.h>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include "avm_cnr_json_helper.h"
#include <LtsSession/lts_session.h>
#include <ExerciseManagement/exm_data_plugin_interface.h>
#include <AudioVideoManagement/avm_data_plugin_interface.h>
#include <AudioVideoManagement/avm_ftc.h>
#include <Core/core.hpp>
#include <ExerciseManagement/exm_data_plugin_interface.h>
#include <FileManagement/flm_translation.h>
#include <LtsSession/lts_session.h>
#include <LtsSession/lts_session_data.h>
#include <ParticipantManagement/ppm_translation.h>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
namespace AudioVideoManagement
{
LoadCombatNetRadioDialogModel::LoadCombatNetRadioDialogModel(const QByteArray &data,
LtsSession::LtsSession *session,
QObject *parent)
: LtsAbstractTableModel<CnrConfig>(
LoadCombatNetRadioDialogModel::LoadCombatNetRadioDialogModel(const QByteArray& data, LtsSession::LtsSession* session,
QObject* parent)
: LtsAbstractTableModel<CnrConfig>(
{tr("Include"), tr("Channel"), tr("Radio Circuit"), tr("Code Word"), tr("Conflict(s)")}, parent),
m_exerciseId(session == nullptr ? 0 : session->exerciseId())
{
tr("Include"),
tr("Channel"),
tr("Radio Circuit"),
tr("Code Word"),
tr("Conflict(s)")
}, parent)
, m_exerciseId(session == nullptr ? 0 : session->exerciseId())
{
DEBUG_LOG(m_logger) << "Own exercise id: " << m_exerciseId;
DEBUG_LOG(m_logger) << "Own exercise id: " << m_exerciseId;
if (session != nullptr)
{
std::shared_ptr<AudioVideoManagement::Interface::Dtc> avmDtc;
if (!session->getDtc<AudioVideoManagement::DataInterface>(avmDtc)
|| !avmDtc->enableCnrChannel()
|| !avmDtc->enableCnrConfig())
ERROR_LOG(m_logger) << "Could not get AVM data";
else
if (session != nullptr)
{
m_cnrChannels = avmDtc->cnrChannels();
m_cnrConfigs = avmDtc->cnrConfigs();
std::shared_ptr<AudioVideoManagement::Interface::Dtc> avmDtc;
if (!session->getDtc<AudioVideoManagement::DataInterface>(avmDtc) || !avmDtc->enableCnrChannel() ||
!avmDtc->enableCnrConfig())
ERROR_LOG(m_logger) << "Could not get AVM data";
else
{
m_cnrChannels = avmDtc->cnrChannels();
m_cnrConfigs = avmDtc->cnrConfigs();
}
DEBUG_LOG(m_logger) << "cnrconfigs: " << m_cnrConfigs.size();
DEBUG_LOG(m_logger) << "ownExerciseId: " << m_exerciseId;
std::shared_ptr<ExerciseManagement::Interface::Dtc> exmDtc;
if (!session->getDtc<ExerciseManagement::DataInterface>(exmDtc) || !exmDtc->enableExercise())
ERROR_LOG(m_logger) << "Could not get EXM data";
else
m_exercises = exmDtc->exercises();
DEBUG_LOG(m_logger) << "exercises: " << m_exercises.size();
}
else
ERROR_LOG(m_logger) << "Got invalid session.";
m_vecData = jsonToCnrConfigVector(data);
m_includeStates.reserve(m_vecData.size());
m_conflicts.reserve(m_vecData.size());
for (int32_t idxCounter = 0; idxCounter < m_vecData.size(); ++idxCounter)
{
Conflicts conflicts = getConflicts(idxCounter, m_vecData.at(idxCounter));
m_conflicts.append(conflicts);
m_includeStates.append(conflicts == NO_CONFLICT ? Qt::Checked : Qt::Unchecked);
if (conflicts & CHANNEL_TAKEN_IN_GLOBAL || conflicts & RADIO_CIRCUIT_TAKEN_IN_GLOBAL)
m_disabledRows.append(idxCounter);
}
}
Qt::ItemFlags LoadCombatNetRadioDialogModel::flags(const QModelIndex& index) const
{
if (indexIsValid(index) && m_disabledRows.contains(index.row()))
return Qt::NoItemFlags;
if (index.column() > 0)
return LtsAbstractTableModel::flags(index);
return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | LtsAbstractTableModel::flags(index);
}
bool LoadCombatNetRadioDialogModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (indexIsValid(index) && role == Qt::CheckStateRole && index.column() == 0 && value.canConvert<Qt::CheckState>())
{
m_includeStates[index.row()] = value.value<Qt::CheckState>();
emit dataChanged(index, index, {role});
return true;
}
DEBUG_LOG(m_logger) << "cnrconfigs: " << m_cnrConfigs.size();
DEBUG_LOG(m_logger) << "ownExerciseId: " << m_exerciseId;
std::shared_ptr<ExerciseManagement::Interface::Dtc> exmDtc;
if (!session->getDtc<ExerciseManagement::DataInterface>(exmDtc)
|| !exmDtc->enableExercise())
ERROR_LOG(m_logger) << "Could not get EXM data";
else
m_exercises = exmDtc->exercises();
DEBUG_LOG(m_logger) << "exercises: " << m_exercises.size();
}
else
ERROR_LOG(m_logger) << "Got invalid session.";
m_vecData = jsonToCnrConfigVector(data);
m_includeStates.reserve(m_vecData.size());
m_conflicts.reserve(m_vecData.size());
for (int32_t idxCounter = 0; idxCounter < m_vecData.size(); ++idxCounter)
{
Conflicts conflicts = getConflicts(idxCounter, m_vecData.at(idxCounter));
m_conflicts.append(conflicts);
m_includeStates.append(conflicts == NO_CONFLICT ? Qt::Checked : Qt::Unchecked);
if (conflicts & CHANNEL_TAKEN_IN_GLOBAL || conflicts & RADIO_CIRCUIT_TAKEN_IN_GLOBAL)
m_disabledRows.append(idxCounter);
}
return QAbstractTableModel::setData(index, value, role);
}
Qt::ItemFlags LoadCombatNetRadioDialogModel::flags(const QModelIndex &index) const
QVariant LoadCombatNetRadioDialogModel::data(const QModelIndex& index, int role) const
{
if (indexIsValid(index) && m_disabledRows.contains(index.row()))
return Qt::NoItemFlags;
if (!indexIsValid(index))
return QVariant();
if (index.column() > 0)
return LtsAbstractTableModel::flags(index);
return Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | LtsAbstractTableModel::flags(index);
}
bool LoadCombatNetRadioDialogModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (indexIsValid(index)
&& role == Qt::CheckStateRole
&& index.column() == 0
&& value.canConvert<Qt::CheckState>())
{
m_includeStates[index.row()] = value.value<Qt::CheckState>();
emit dataChanged(index, index, {role});
return true;
}
return QAbstractTableModel::setData(index, value, role);
}
QVariant LoadCombatNetRadioDialogModel::data(const QModelIndex &index, int role) const
{
if (!indexIsValid(index))
return QVariant();
switch (role)
{
case Qt::DisplayRole:
{
const CnrConfig &config = m_vecData.at(index.row());
switch (index.column())
switch (role)
{
case CHANNEL:
return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId()).name());
case RADIO_CIRCUIT:
return QString::fromStdString(config.radioCircuit());
case CALL_SIGN:
return QString::fromStdString(config.callSign());
case CONFLICTS:
return conflictsText(m_conflicts.at(index.row()));
default:
return QVariant();
case Qt::DisplayRole: {
const CnrConfig& config = m_vecData.at(index.row());
switch (index.column())
{
case CHANNEL:
return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId()).name());
case RADIO_CIRCUIT:
return QString::fromStdString(config.radioCircuit());
case CALL_SIGN:
return QString::fromStdString(config.callSign());
case CONFLICTS:
return conflictsText(m_conflicts.at(index.row()));
default:
return QVariant();
}
}
case Qt::CheckStateRole:
if (index.column() != 0)
return QVariant();
return m_includeStates.at(index.row());
case Qt::BackgroundRole:
return getConflictsRowColor(m_conflicts.at(index.row()));
default:
return QVariant();
}
}
case Qt::CheckStateRole:
if (index.column() != 0)
return QVariant();
return m_includeStates.at(index.row());
case Qt::BackgroundRole:
return getConflictsRowColor(m_conflicts.at(index.row()));
default:
return QVariant();
}
}
bool LoadCombatNetRadioDialogModel::allChecked() const
{
for (int32_t row = 0; row < m_includeStates.size(); ++row)
{
if (m_disabledRows.contains(row))
continue;
for (int32_t row = 0; row < m_includeStates.size(); ++row)
{
if (m_disabledRows.contains(row))
continue;
if (m_includeStates.at(row) == Qt::Unchecked)
return false;
}
if (m_includeStates.at(row) == Qt::Unchecked)
return false;
}
return true;
return true;
}
void LoadCombatNetRadioDialogModel::setCheckState(bool isChecked)
{
const QVariant data = QVariant(isChecked ? Qt::Checked : Qt::Unchecked);
const int role = Qt::CheckStateRole;
const QVariant data = QVariant(isChecked ? Qt::Checked : Qt::Unchecked);
const int role = Qt::CheckStateRole;
for (int32_t row = 0; row < rowCount(); ++row)
{
if (m_disabledRows.contains(row))
continue;
for (int32_t row = 0; row < rowCount(); ++row)
{
if (m_disabledRows.contains(row))
continue;
setData(createIndex(row, 0), data, role);
}
setData(createIndex(row, 0), data, role);
}
}
LoadCombatNetRadioDialogModel::Conflicts LoadCombatNetRadioDialogModel::getConflicts(int32_t row, const CnrConfig &config)
LoadCombatNetRadioDialogModel::Conflicts LoadCombatNetRadioDialogModel::getConflicts(int32_t row,
const CnrConfig& config)
{
Conflicts conflicts = NO_CONFLICT;
Conflicts conflicts = NO_CONFLICT;
for (auto it = m_cnrConfigs.constBegin(); it != m_cnrConfigs.constEnd(); ++it)
{
if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG) && isRadioCircuitTakenInOwnConfig(config, it.value()))
for (auto it = m_cnrConfigs.constBegin(); it != m_cnrConfigs.constEnd(); ++it)
{
conflicts |= RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG;
addConflictedCnr(row, it.value().id());
if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG) && isRadioCircuitTakenInOwnConfig(config, it.value()))
{
conflicts |= RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE) &&
isRadioCircuitTakenInAnotherExercise(config, it.value()))
{
conflicts |= RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_ACTIVE_EXERCISE) && isChannelTakenInActiveExercise(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_ACTIVE_EXERCISE;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_LINKED_EXERCISE) && isChannelTakenInLinkedExercise(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_LINKED_EXERCISE;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_OWN_CONFIG) && isChannelTakenInOwnConfig(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_OWN_CONFIG;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_GLOBAL) && isChannelTakenInGlobal(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_GLOBAL;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_GLOBAL) && isRadioCircuitTakenInGlobal(config, it.value()))
{
conflicts |= RADIO_CIRCUIT_TAKEN_IN_GLOBAL;
addConflictedCnr(row, it.value().id());
}
}
if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE) && isRadioCircuitTakenInAnotherExercise(config, it.value()))
{
conflicts |= RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_ACTIVE_EXERCISE) && isChannelTakenInActiveExercise(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_ACTIVE_EXERCISE;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_LINKED_EXERCISE) && isChannelTakenInLinkedExercise(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_LINKED_EXERCISE;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_OWN_CONFIG) && isChannelTakenInOwnConfig(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_OWN_CONFIG;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & CHANNEL_TAKEN_IN_GLOBAL) && isChannelTakenInGlobal(config, it.value()))
{
conflicts |= CHANNEL_TAKEN_IN_GLOBAL;
addConflictedCnr(row, it.value().id());
}
if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_GLOBAL) && isRadioCircuitTakenInGlobal(config, it.value()))
{
conflicts |= RADIO_CIRCUIT_TAKEN_IN_GLOBAL;
addConflictedCnr(row, it.value().id());
}
}
return conflicts;
return conflicts;
}
QString LoadCombatNetRadioDialogModel::conflictsText(Conflicts conflicts) const
{
QStringList conflictTexts;
QStringList conflictTexts;
if (conflicts & RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG)
conflictTexts.append(tr("Radio Circuit is already taken in own config."));
if (conflicts & RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG)
conflictTexts.append(tr("Radio Circuit is already taken in own config."));
if (conflicts & RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE)
conflictTexts.append(tr("Radio Circuit is already taken in another exercise."));
if (conflicts & RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE)
conflictTexts.append(tr("Radio Circuit is already taken in another exercise."));
if (conflicts & CHANNEL_TAKEN_IN_ACTIVE_EXERCISE)
conflictTexts.append(tr("Channel already taken in active exercise."));
if (conflicts & CHANNEL_TAKEN_IN_ACTIVE_EXERCISE)
conflictTexts.append(tr("Channel already taken in active exercise."));
if (conflicts & CHANNEL_TAKEN_IN_LINKED_EXERCISE)
conflictTexts.append(tr("Channel already taken in linked exercise."));
if (conflicts & CHANNEL_TAKEN_IN_LINKED_EXERCISE)
conflictTexts.append(tr("Channel already taken in linked exercise."));
if (conflicts & CHANNEL_TAKEN_IN_OWN_CONFIG)
conflictTexts.append(tr("Channel is already taken in own Cnr Config."));
if (conflicts & CHANNEL_TAKEN_IN_OWN_CONFIG)
conflictTexts.append(tr("Channel is already taken in own Cnr Config."));
if (conflicts & CHANNEL_TAKEN_IN_GLOBAL)
conflictTexts.append(tr("Channel already taken in global Cnr Config."));
if (conflicts & CHANNEL_TAKEN_IN_GLOBAL)
conflictTexts.append(tr("Channel already taken in global Cnr Config."));
if (conflicts & RADIO_CIRCUIT_TAKEN_IN_GLOBAL)
conflictTexts.append(tr("Radio Circuit already taken in global Cnr Config."));
if (conflicts & RADIO_CIRCUIT_TAKEN_IN_GLOBAL)
conflictTexts.append(tr("Radio Circuit already taken in global Cnr Config."));
return conflictTexts.isEmpty() ? QLatin1String("-") : conflictTexts.join(QLatin1Char('\n'));
return conflictTexts.isEmpty() ? QLatin1String("-") : conflictTexts.join(QLatin1Char('\n'));
}
void LoadCombatNetRadioDialogModel::addConflictedCnr(int32_t row, int32_t cnrConfigId)
{
m_conflictedCnrIds[row].append(cnrConfigId);
m_conflictedCnrIds[row].append(cnrConfigId);
}
bool LoadCombatNetRadioDialogModel::isActiveExercise(int32_t exerciseId) const
{
if (exerciseId == 0)
return true;
if (exerciseId == 0)
return true;
using namespace ExerciseManagement;
using namespace ExerciseManagement;
ExerciseState exerciseState = m_exercises.value(exerciseId).state();
ExerciseState exerciseState = m_exercises.value(exerciseId).state();
return exerciseState == ExerciseState::Started || exerciseState == ExerciseState::Paused;
return exerciseState == ExerciseState::Started || exerciseState == ExerciseState::Paused;
}
QColor LoadCombatNetRadioDialogModel::getConflictsRowColor(Conflicts conflicts) const
{
if (conflicts >= CHANNEL_TAKEN_IN_GLOBAL)
return QColor(Qt::red).lighter();
if (conflicts >= CHANNEL_TAKEN_IN_GLOBAL)
return QColor(Qt::red).lighter();
if (conflicts > NO_CONFLICT)
return QColor(Qt::yellow).lighter();
if (conflicts > NO_CONFLICT)
return QColor(Qt::yellow).lighter();
return QColor(Qt::green).lighter();
return QColor(Qt::green).lighter();
}
bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInOwnConfig(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInOwnConfig(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
if (m_exerciseId == 0)
return !existingConfig.exerciseId().is_set() && existingConfig.radioCircuit() == loadConfig.radioCircuit();
if (m_exerciseId == 0)
return !existingConfig.exerciseId().is_set() && existingConfig.radioCircuit() == loadConfig.radioCircuit();
if (!existingConfig.exerciseId().is_set()
|| existingConfig.exerciseId().get() != m_exerciseId
|| existingConfig.radioCircuit() != loadConfig.radioCircuit())
return false;
if (!existingConfig.exerciseId().is_set() || existingConfig.exerciseId().get() != m_exerciseId ||
existingConfig.radioCircuit() != loadConfig.radioCircuit())
return false;
return true;
return true;
}
bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInAnotherExercise(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInAnotherExercise(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
if (!isActiveExercise(m_exerciseId)
|| !existingConfig.exerciseId().is_set()
|| !isActiveExercise(existingConfig.exerciseId().get())
|| existingConfig.exerciseId().get() == m_exerciseId
|| existingConfig.radioCircuit() != loadConfig.radioCircuit())
return false;
if (!isActiveExercise(m_exerciseId) || !existingConfig.exerciseId().is_set() ||
!isActiveExercise(existingConfig.exerciseId().get()) || existingConfig.exerciseId().get() == m_exerciseId ||
existingConfig.radioCircuit() != loadConfig.radioCircuit())
return false;
return true;
return true;
}
bool LoadCombatNetRadioDialogModel::isChannelTakenInActiveExercise(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isChannelTakenInActiveExercise(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
int32_t exerciseId = existingConfig.exerciseId().is_set() ? existingConfig.exerciseId().get() : 0;
int32_t exerciseId = existingConfig.exerciseId().is_set() ? existingConfig.exerciseId().get() : 0;
if (!isActiveExercise(m_exerciseId)
|| exerciseId == 0
|| exerciseId == m_exerciseId
|| !isActiveExercise(exerciseId)
|| existingConfig.cnrChannelId() != loadConfig.cnrChannelId()
|| !isActiveExercise(exerciseId))
return false;
if (!isActiveExercise(m_exerciseId) || exerciseId == 0 || exerciseId == m_exerciseId ||
!isActiveExercise(exerciseId) || existingConfig.cnrChannelId() != loadConfig.cnrChannelId() ||
!isActiveExercise(exerciseId))
return false;
return true;
return true;
}
bool LoadCombatNetRadioDialogModel::isChannelTakenInLinkedExercise(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isChannelTakenInLinkedExercise(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
if (m_exerciseId == 0 || m_exercises.value(m_exerciseId).linkedExerciseId() == 0)
return false;
if (m_exerciseId == 0 || m_exercises.value(m_exerciseId).linkedExerciseId() == 0)
return false;
int32_t linkedExerciseId = m_exercises.value(m_exerciseId).linkedExerciseId();
int32_t linkedExerciseId = m_exercises.value(m_exerciseId).linkedExerciseId();
int32_t exerciseId = existingConfig.exerciseId().is_set() ? existingConfig.exerciseId().get() : 0;
int32_t exerciseId = existingConfig.exerciseId().is_set() ? existingConfig.exerciseId().get() : 0;
if (exerciseId != linkedExerciseId || existingConfig.cnrChannelId() != loadConfig.cnrChannelId())
return false;
if (exerciseId != linkedExerciseId || existingConfig.cnrChannelId() != loadConfig.cnrChannelId())
return false;
return true;
return true;
}
bool LoadCombatNetRadioDialogModel::isChannelTakenInOwnConfig(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isChannelTakenInOwnConfig(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
int32_t exerciseId = existingConfig.exerciseId().is_set() ? existingConfig.exerciseId().get() : 0;
int32_t exerciseId = existingConfig.exerciseId().is_set() ? existingConfig.exerciseId().get() : 0;
return existingConfig.cnrChannelId() == loadConfig.cnrChannelId() && exerciseId == m_exerciseId;
return existingConfig.cnrChannelId() == loadConfig.cnrChannelId() && exerciseId == m_exerciseId;
}
bool LoadCombatNetRadioDialogModel::isChannelTakenInGlobal(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isChannelTakenInGlobal(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
if (!isActiveExercise(m_exerciseId)
|| m_exerciseId == 0
|| existingConfig.exerciseId().is_set()
|| existingConfig.cnrChannelId() != loadConfig.cnrChannelId())
return false;
if (!isActiveExercise(m_exerciseId) || m_exerciseId == 0 || existingConfig.exerciseId().is_set() ||
existingConfig.cnrChannelId() != loadConfig.cnrChannelId())
return false;
return true;
return true;
}
bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInGlobal(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const
bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInGlobal(const CnrConfig& loadConfig,
const CnrConfig& existingConfig) const
{
if (!isActiveExercise(m_exerciseId)
|| m_exerciseId == 0
|| existingConfig.exerciseId().is_set()
|| existingConfig.radioCircuit() != loadConfig.radioCircuit())
return false;
if (!isActiveExercise(m_exerciseId) || m_exerciseId == 0 || existingConfig.exerciseId().is_set() ||
existingConfig.radioCircuit() != loadConfig.radioCircuit())
return false;
return true;
return true;
}
QVector<Core::RemoveElementRequest> LoadCombatNetRadioDialogModel::removeRequests() const
{
QVector<Core::RemoveElementRequest> removeRequestsVec;
QVector<Core::RemoveElementRequest> removeRequestsVec;
for (int32_t idxCounter = 0; idxCounter < m_includeStates.size(); ++idxCounter)
{
if (m_includeStates.at(idxCounter) == Qt::Checked && m_conflicts.at(idxCounter) != NO_CONFLICT)
for (int32_t idxCounter = 0; idxCounter < m_includeStates.size(); ++idxCounter)
{
if (!m_conflictedCnrIds.contains(idxCounter))
{
WARNING_LOG(m_logger) << "Tried to get remove request for row " << idxCounter << " but it is not present.";
continue;
}
if (m_includeStates.at(idxCounter) == Qt::Checked && m_conflicts.at(idxCounter) != NO_CONFLICT)
{
if (!m_conflictedCnrIds.contains(idxCounter))
{
WARNING_LOG(m_logger) << "Tried to get remove request for row " << idxCounter
<< " but it is not present.";
continue;
}
const QVector<int32_t> cnrConfigIds = m_conflictedCnrIds.value(idxCounter);
const QVector<int32_t> cnrConfigIds = m_conflictedCnrIds.value(idxCounter);
for (int32_t cnrConfigId : cnrConfigIds)
{
Core::RemoveElementRequest removeRequest(cnrConfigId);
for (int32_t cnrConfigId : cnrConfigIds)
{
Core::RemoveElementRequest removeRequest(cnrConfigId);
if (!removeRequestsVec.contains(removeRequest))
removeRequestsVec.append(removeRequest);
}
if (!removeRequestsVec.contains(removeRequest))
removeRequestsVec.append(removeRequest);
}
}
}
}
return removeRequestsVec;
return removeRequestsVec;
}
QVector<ModifyCnrConfigRequest> LoadCombatNetRadioDialogModel::modifyRequests() const
{
const dds::core::optional<int32_t> exerciseId = m_exerciseId == 0 ? dds::core::optional<int32_t>() : dds::core::optional<int32_t>(m_exerciseId);
const int32_t partyId = m_exerciseId == 0 ? 1 : 0;
QVector<ModifyCnrConfigRequest> modifyRequestsVec;
const dds::core::optional<int32_t> exerciseId =
m_exerciseId == 0 ? dds::core::optional<int32_t>() : dds::core::optional<int32_t>(m_exerciseId);
const int32_t partyId = m_exerciseId == 0 ? 1 : 0;
QVector<ModifyCnrConfigRequest> modifyRequestsVec;
modifyRequestsVec.reserve(m_includeStates.size());
modifyRequestsVec.reserve(m_includeStates.size());
for (int32_t row = 0; row < m_includeStates.size(); ++row)
{
if (m_includeStates.at(row) != Qt::Checked)
continue;
for (int32_t row = 0; row < m_includeStates.size(); ++row)
{
if (m_includeStates.at(row) != Qt::Checked)
continue;
const CnrConfig &cnrConfig = m_vecData.at(row);
const CnrConfig& cnrConfig = m_vecData.at(row);
modifyRequestsVec.append({0,
cnrConfig.cnrChannelId(),
exerciseId,
cnrConfig.radioCircuit(),
cnrConfig.recording(),
{},
partyId,
cnrConfig.callSign()});
}
modifyRequestsVec.append({0,
cnrConfig.cnrChannelId(),
exerciseId,
cnrConfig.radioCircuit(),
cnrConfig.recording(),
{},
partyId,
cnrConfig.callSign()});
}
return modifyRequestsVec;
return modifyRequestsVec;
}
}
} // namespace AudioVideoManagement
@@ -1,14 +1,13 @@
#pragma once
#include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/logger.h>
#include <ExerciseManagement/exm_dtc.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
#include <AudioVideoManagement/logger.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <ExerciseManagement/exm_dtc.h>
#include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
namespace Core
{
@@ -21,7 +20,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace LtsSession
{
@@ -31,83 +30,70 @@ class LtsSession;
namespace AudioVideoManagement
{
class LoadCombatNetRadioDialogModel final
: public LtsWidgets::LtsAbstractTableModel<CnrConfig>
class LoadCombatNetRadioDialogModel final : public LtsWidgets::LtsAbstractTableModel<CnrConfig>
{
Q_OBJECT
Q_OBJECT
public:
enum Columns
{
INCLUDE,
CHANNEL,
RADIO_CIRCUIT,
CALL_SIGN,
CONFLICTS
};
public:
enum Columns { INCLUDE, CHANNEL, RADIO_CIRCUIT, CALL_SIGN, CONFLICTS };
enum Conflict
{
NO_CONFLICT = 0,
RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG = 0b00000001,
RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE = 0b00000010,
CHANNEL_TAKEN_IN_ACTIVE_EXERCISE = 0b00000100,
CHANNEL_TAKEN_IN_LINKED_EXERCISE = 0b00001000,
CHANNEL_TAKEN_IN_OWN_CONFIG = 0b00010000,
enum Conflict {
NO_CONFLICT = 0,
RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG = 0b00000001,
RADIO_CIRCUIT_TAKEN_IN_ANOTHER_EXERCISE = 0b00000010,
CHANNEL_TAKEN_IN_ACTIVE_EXERCISE = 0b00000100,
CHANNEL_TAKEN_IN_LINKED_EXERCISE = 0b00001000,
CHANNEL_TAKEN_IN_OWN_CONFIG = 0b00010000,
CHANNEL_TAKEN_IN_GLOBAL = 0b00100000,
RADIO_CIRCUIT_TAKEN_IN_GLOBAL = 0b01000000,
};
Q_DECLARE_FLAGS(Conflicts, Conflict)
CHANNEL_TAKEN_IN_GLOBAL = 0b00100000,
RADIO_CIRCUIT_TAKEN_IN_GLOBAL = 0b01000000,
};
Q_DECLARE_FLAGS(Conflicts, Conflict)
explicit LoadCombatNetRadioDialogModel(const QByteArray &data,
LtsSession::LtsSession *session,
QObject *parent = nullptr);
explicit LoadCombatNetRadioDialogModel(const QByteArray& data, LtsSession::LtsSession* session,
QObject* parent = nullptr);
Qt::ItemFlags flags(const QModelIndex &index) const override;
Qt::ItemFlags flags(const QModelIndex& index) const override;
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
QVariant data(const QModelIndex &index, int role) const override;
QVariant data(const QModelIndex& index, int role) const override;
bool allChecked() const;
bool allChecked() const;
QVector<Core::RemoveElementRequest> removeRequests() const;
QVector<AudioVideoManagement::ModifyCnrConfigRequest> modifyRequests() const;
QVector<Core::RemoveElementRequest> removeRequests() const;
QVector<AudioVideoManagement::ModifyCnrConfigRequest> modifyRequests() const;
public Q_SLOTS:
void setCheckState(bool isChecked);
public Q_SLOTS:
void setCheckState(bool isChecked);
private:
private:
NGL::INGLLogger& m_logger;
LoadCombatNetRadioDialogModel::Conflicts getConflicts(int32_t row, const CnrConfig& config);
QString conflictsText(Conflicts conflicts) const;
bool isRadioCircuitTakenInOwnConfig(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
bool isRadioCircuitTakenInAnotherExercise(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
bool isChannelTakenInActiveExercise(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
bool isChannelTakenInLinkedExercise(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
bool isChannelTakenInOwnConfig(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
bool isChannelTakenInGlobal(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
bool isRadioCircuitTakenInGlobal(const CnrConfig& loadConfig, const CnrConfig& existingConfig) const;
NGL::INGLLogger &m_logger;
LoadCombatNetRadioDialogModel::Conflicts getConflicts(int32_t row, const CnrConfig &config);
QString conflictsText(Conflicts conflicts) const;
void addConflictedCnr(int32_t row, int32_t cnrConfigId);
bool isRadioCircuitTakenInOwnConfig(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isRadioCircuitTakenInAnotherExercise(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isChannelTakenInActiveExercise(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isChannelTakenInLinkedExercise(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isChannelTakenInOwnConfig(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isChannelTakenInGlobal(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isRadioCircuitTakenInGlobal(const CnrConfig &loadConfig, const CnrConfig &existingConfig) const;
bool isActiveExercise(int32_t exerciseId) const;
void addConflictedCnr(int32_t row, int32_t cnrConfigId);
QColor getConflictsRowColor(Conflicts conflicts) const;
bool isActiveExercise(int32_t exerciseId) const;
QColor getConflictsRowColor(Conflicts conflicts) const;
private:
int32_t m_exerciseId;
QMap<int32_t, CnrChannel> m_cnrChannels;
QMap<int32_t, CnrConfig> m_cnrConfigs;
QMap<int32_t, ExerciseManagement::Exercise> m_exercises;
QMap<int32_t, QVector<int32_t> > m_conflictedCnrIds;
QVector<Qt::CheckState> m_includeStates;
QVector<int32_t> m_disabledRows;
QVector<Conflicts> m_conflicts;
private:
int32_t m_exerciseId;
QMap<int32_t, CnrChannel> m_cnrChannels;
QMap<int32_t, CnrConfig> m_cnrConfigs;
QMap<int32_t, ExerciseManagement::Exercise> m_exercises;
QMap<int32_t, QVector<int32_t>> m_conflictedCnrIds;
QVector<Qt::CheckState> m_includeStates;
QVector<int32_t> m_disabledRows;
QVector<Conflicts> m_conflicts;
};
}
} // namespace AudioVideoManagement
@@ -1,422 +1,382 @@
#include "avm_edit_frequency_planning_dialog.h"
#include <utility>
#include "ui_avm_edit_frequency_planning_dialog.h"
#include "avm_edit_frequency_planning_frequency_data_model.h"
#include "avm_load_frequency_planning_dialog.h"
#include "ui_avm_edit_frequency_planning_dialog.h"
#include <AudioVideoManagement/avm_ftc.h>
#include <ExerciseManagement/exm_dtc.h>
#include <FileManagement/flm_translation.h>
#include <InfrastructureManagement/ism_dtc.h>
#include <LtsDataView/lts_data_view.h>
#include <LtsPrinting/printing.h>
#include <LtsSession/lts_session.h>
#include <LtsSession/lts_session_data.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <ParticipantManagement/ppm.hpp>
#include <ParticipantManagement/ppm_translation.h>
#include <AudioVideoManagement/avm_ftc.h>
#include <InfrastructureManagement/ism_dtc.h>
#include <ExerciseManagement/exm_dtc.h>
#include <LtsSession/lts_session_data.h>
#include <ngltools/ngltools_dtg.h>
#include <LtsDataView/lts_data_view.h>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <FileManagement/flm_translation.h>
#include "avm_load_frequency_planning_dialog.h"
#include <LtsSession/lts_session.h>
#include <LtsPrinting/printing.h>
#include <QTreeView>
#include <ngltools/ngltools_dtg.h>
#include <utility>
namespace
{
bool isActive(ExerciseManagement::ExerciseState state)
{
return (state == ExerciseManagement::ExerciseState::Started ||
state == ExerciseManagement::ExerciseState::Paused);
return (state == ExerciseManagement::ExerciseState::Started || state == ExerciseManagement::ExerciseState::Paused);
}
}
} // namespace
namespace AudioVideoManagement
{
EditFrequencyPlanningDialog::EditFrequencyPlanningDialog(LtsSession::LtsSession *session,
const QString &menuGroup,
const QString &freqPlanningDialogIdentifier,
const FrequencyPlanning &planning,
const bool copy,
const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc> &ismDtc,
ExerciseManagement::Interface::Dtc *exmDtc,
QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
, m_session(session)
, m_menuGroup(menuGroup)
, m_freqPlanningDialogIdentifier(freqPlanningDialogIdentifier)
, m_ui(new Ui::EditFrequencyPlanningDialog)
, m_planning(planning)
, m_avmDtc(avmDtc)
, m_avmFtc(avmFtc)
, m_ppmDtc(ppmDtc)
, m_ismDtc(ismDtc)
, m_exmDtc(exmDtc)
, m_requestHelper(new LtsUtils::RequestHelper(this))
, m_frequencyDataModel(new EditFrequencyPlanningFrequencyDataModel(planning, m_session->exerciseId(), avmDtc, ismDtc, ppmDtc, this))
, m_frequencyPlanningId(copy ? 0 : planning.id())
, m_exerciseId(session->exerciseId())
, m_isEdit(EditFrequencyPlanningSetResourceDialog::DialogMode::Assign)
, m_activeFrequencyPlanningStatus(0)
EditFrequencyPlanningDialog::EditFrequencyPlanningDialog(
LtsSession::LtsSession* session, const QString& menuGroup, const QString& freqPlanningDialogIdentifier,
const FrequencyPlanning& planning, const bool copy, const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<Interface::Ftc>& avmFtc, const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc>& ismDtc, ExerciseManagement::Interface::Dtc* exmDtc,
QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel), m_session(session),
m_menuGroup(menuGroup), m_freqPlanningDialogIdentifier(freqPlanningDialogIdentifier),
m_ui(new Ui::EditFrequencyPlanningDialog), m_planning(planning), m_avmDtc(avmDtc), m_avmFtc(avmFtc),
m_ppmDtc(ppmDtc), m_ismDtc(ismDtc), m_exmDtc(exmDtc), m_requestHelper(new LtsUtils::RequestHelper(this)),
m_frequencyDataModel(
new EditFrequencyPlanningFrequencyDataModel(planning, m_session->exerciseId(), avmDtc, ismDtc, ppmDtc, this)),
m_frequencyPlanningId(copy ? 0 : planning.id()), m_exerciseId(session->exerciseId()),
m_isEdit(EditFrequencyPlanningSetResourceDialog::DialogMode::Assign), m_activeFrequencyPlanningStatus(0)
{
m_ui->setupUi(this);
m_ui->setupUi(this);
m_ui->leName->setText(QString::fromStdString(m_planning.name()));
m_ui->lbDate->setText(DTG::toStringMSec(m_planning.date()));
m_ui->leName->setText(QString::fromStdString(m_planning.name()));
m_ui->lbDate->setText(DTG::toStringMSec(m_planning.date()));
m_uiRequirements->addRequirement( { m_ui->label, [this]() { return !m_ui->leName->text().isEmpty(); } });
m_uiRequirements->addRequirement({m_ui->label, [this]() { return !m_ui->leName->text().isEmpty(); }});
FPFDelegate *treeDelegate = new FPFDelegate(m_frequencyDataModel);
m_ui->dvFrequencyData->treeView()->setItemDelegateForColumn(EditFrequencyPlanningFrequencyDataModel::Columns::PROPERTIES, treeDelegate);
FPFDelegate* treeDelegate = new FPFDelegate(m_frequencyDataModel);
m_ui->dvFrequencyData->treeView()->setItemDelegateForColumn(
EditFrequencyPlanningFrequencyDataModel::Columns::PROPERTIES, treeDelegate);
m_ui->dvFrequencyData->setModel(m_frequencyDataModel);
m_ui->dvFrequencyData->expandAll();
m_ui->dvFrequencyData->setModel(m_frequencyDataModel);
m_ui->dvFrequencyData->expandAll();
#ifndef LTS_DEBUG
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::RADIO_CIRCUIT_ID);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::RADIO_CIRCUIT_ID);
#endif
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::AKW_BUNDLE);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::AKW_RADIO_CIRCUIT);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::FSB_BUNDLE);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::COMSEC);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::DEVICE);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::PILOTTON);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::AKW_BUNDLE);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::AKW_RADIO_CIRCUIT);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::FSB_BUNDLE);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::COMSEC);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::DEVICE);
m_ui->dvFrequencyData->hideColumn(EditFrequencyPlanningFrequencyDataModel::Columns::PILOTTON);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &EditFrequencyPlanningDialog::onAddClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &EditFrequencyPlanningDialog::onRemoveClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &EditFrequencyPlanningDialog::onPrint);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &EditFrequencyPlanningDialog::onAddClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &EditFrequencyPlanningDialog::onRemoveClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &EditFrequencyPlanningDialog::onPrint);
connect(m_ui->dvFrequencyData, &LtsDataView::LtsDataView::signalSelectionChanged,
this, &EditFrequencyPlanningDialog::enableSelectedUnassignButton);
connect(m_ui->dvFrequencyData, &LtsDataView::LtsDataView::signalSelectionChanged, this,
&EditFrequencyPlanningDialog::enableSelectedUnassignButton);
connect(m_ui->dvFrequencyData, &LtsDataView::LtsDataView::signalDoubleClicked,
this, &EditFrequencyPlanningDialog::onAddClicked);
connect(m_ui->dvFrequencyData, &LtsDataView::LtsDataView::signalDoubleClicked, this,
&EditFrequencyPlanningDialog::onAddClicked);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, false);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, false);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, false);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, false);
if (m_frequencyPlanningId == 0)
slotChangesMade();
if (m_frequencyPlanningId == 0)
slotChangesMade();
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Assign"));
m_buttonBox->setText(LtsWidgets::DialogButton::Remove, tr("Unassign"));
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Assign"));
m_buttonBox->setText(LtsWidgets::DialogButton::Remove, tr("Unassign"));
m_buttonBox->connectLibraryButton(this,
&EditFrequencyPlanningDialog::onImportButtonClicked,
&EditFrequencyPlanningDialog::onExportButtonClicked);
m_buttonBox->connectLibraryButton(this, &EditFrequencyPlanningDialog::onImportButtonClicked,
&EditFrequencyPlanningDialog::onExportButtonClicked);
if (!session->getForeignGuiInterface<FileManagement::ForeignGuiInterface>(m_flmGui))
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Library, false);
if (!session->getForeignGuiInterface<FileManagement::ForeignGuiInterface>(m_flmGui))
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Library, false);
setOnlineHelpFilename(QStringLiteral("Situation-Frequency_Planning"));
setOnlineHelpFilename(QStringLiteral("Situation-Frequency_Planning"));
}
EditFrequencyPlanningDialog::~EditFrequencyPlanningDialog()
{
emit aboutToCloseMe(m_frequencyPlanningId);
emit aboutToCloseMe(m_frequencyPlanningId);
}
void EditFrequencyPlanningDialog::retranslate()
{
translate(m_ui.get(), m_avmDtc->frequencyPlanning(m_frequencyPlanningId), tr("Frequency Planning"));
translate(m_ui.get(), m_avmDtc->frequencyPlanning(m_frequencyPlanningId), tr("Frequency Planning"));
}
void EditFrequencyPlanningDialog::onRemoveFrequencyPlanningReply(const Core::FunctionReplyObject &reply)
void EditFrequencyPlanningDialog::onRemoveFrequencyPlanningReply(const Core::FunctionReplyObject& reply)
{
if (reply.error())
ERROR_LOG(m_logger) << reply.str();
m_requestHelper->requestReply(reply);
if (reply.error())
ERROR_LOG(m_logger) << reply.str();
m_requestHelper->requestReply(reply);
}
void EditFrequencyPlanningDialog::onModifyFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject)
void EditFrequencyPlanningDialog::onModifyFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject)
{
if (!replyObject.error())
m_frequencyDataModel->setFrequencePlanningId(replyObject.id());
m_requestHelper->requestReply(replyObject);
if (!replyObject.error())
m_frequencyDataModel->setFrequencePlanningId(replyObject.id());
m_requestHelper->requestReply(replyObject);
}
bool EditFrequencyPlanningDialog::apply()
{
if (!m_frequencyDataModel->checkResourceAssignments())
{
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Multiple assignments with the same resource are not possible. Please correct the selected entries."));
return false;
}
ModifyFrequencyPlanningRequest request = m_frequencyDataModel->modifyFrequencyPlanningRequest();
if (!m_frequencyDataModel->checkResourceAssignments())
{
LtsWidgets::LtsMessageDialog::showMessage(
this,
tr("Multiple assignments with the same resource are not possible. Please correct the selected entries."));
return false;
}
ModifyFrequencyPlanningRequest request = m_frequencyDataModel->modifyFrequencyPlanningRequest();
request.date(m_session->partitionTime());
m_ui->lbDate->setText(DTG::toStringMSec(request.date()));
m_planning.date() = request.date();
request.id(m_frequencyPlanningId);
request.name(m_ui->leName->text().toStdString());
request.date(m_session->partitionTime());
m_ui->lbDate->setText(DTG::toStringMSec(request.date()));
m_planning.date() = request.date();
request.id(m_frequencyPlanningId);
request.name(m_ui->leName->text().toStdString());
return m_requestHelper->startSingleRequest([this, request]()
{
return m_avmFtc->modifyFrequencyPlanningRequest(request, this);
});
return m_requestHelper->startSingleRequest(
[this, request]() { return m_avmFtc->modifyFrequencyPlanningRequest(request, this); });
}
void EditFrequencyPlanningDialog::onAddClicked()
void EditFrequencyPlanningDialog::onAddClicked()
{
QModelIndex idx = m_ui->dvFrequencyData->currentIndex();
int row = idx.row();
if (row < 0)
return;
QModelIndex idx = m_ui->dvFrequencyData->currentIndex();
int row = idx.row();
if (row < 0)
return;
CnrConfig cnrConfigRow = m_frequencyDataModel->itemData(idx).cnrConfig;
int cnrConfigId = cnrConfigRow.id();
if (cnrConfigId <= 0)
return;
CnrConfig cnrConfigRow = m_frequencyDataModel->itemData(idx).cnrConfig;
int cnrConfigId = cnrConfigRow.id();
if (cnrConfigId <= 0)
return;
DEBUG_LOG(m_logger) << "---RessourceDialog aufrufen...."
<< " cnrConfigId: " << cnrConfigId
<< " radioCircuit: " << cnrConfigRow.radioCircuit()
<< " FrequencySetId: " << m_frequencyDataModel->getFrequencySetId();
DEBUG_LOG(m_logger) << "---RessourceDialog aufrufen...."
<< " cnrConfigId: " << cnrConfigId << " radioCircuit: " << cnrConfigRow.radioCircuit()
<< " FrequencySetId: " << m_frequencyDataModel->getFrequencySetId();
FrequencyPlanningData fpd = m_frequencyDataModel->getfrequencyPlanningData(cnrConfigId);
if (!fpd.cnrConfigId())
{
fpd.cnrConfigId(cnrConfigId);
}
EditFrequencyPlanningResourceDialog *frequencyPlanningResourceDialog
= new EditFrequencyPlanningResourceDialog(m_frequencyDataModel->getFrequencySetId(),
m_isEdit,
this );
FrequencyPlanningData fpd = m_frequencyDataModel->getfrequencyPlanningData(cnrConfigId);
if (!fpd.cnrConfigId())
{
fpd.cnrConfigId(cnrConfigId);
}
frequencyPlanningResourceDialog->init(m_session, fpd, m_frequencyDataModel->getAllocatedFrequencyPlanningSetIds());
connect(this, &QObject::destroyed,
frequencyPlanningResourceDialog, &QObject::deleteLater);
EditFrequencyPlanningResourceDialog* frequencyPlanningResourceDialog =
new EditFrequencyPlanningResourceDialog(m_frequencyDataModel->getFrequencySetId(), m_isEdit, this);
addDialog(frequencyPlanningResourceDialog, m_menuGroup, QLatin1String("avmFrequencyPlanning") + QString::number(cnrConfigId), LtsWidgets::LayoutArea::eDialogTab);
frequencyPlanningResourceDialog->init(m_session, fpd, m_frequencyDataModel->getAllocatedFrequencyPlanningSetIds());
connect(frequencyPlanningResourceDialog, &EditFrequencyPlanningResourceDialog::signalAssignRadioCircuit,
this, &EditFrequencyPlanningDialog::onAssignRadioCircuit);
connect(this, &QObject::destroyed, frequencyPlanningResourceDialog, &QObject::deleteLater);
addDialog(frequencyPlanningResourceDialog, m_menuGroup,
QLatin1String("avmFrequencyPlanning") + QString::number(cnrConfigId), LtsWidgets::LayoutArea::eDialogTab);
connect(frequencyPlanningResourceDialog, &EditFrequencyPlanningResourceDialog::signalAssignRadioCircuit, this,
&EditFrequencyPlanningDialog::onAssignRadioCircuit);
m_ui->dvFrequencyData->expandAll();
}
void EditFrequencyPlanningDialog::onRemoveClicked()
void EditFrequencyPlanningDialog::onRemoveClicked()
{
QModelIndex idx = m_ui->dvFrequencyData->currentIndex();
int row = idx.row();
if (row < 0)
return;
QModelIndex idx = m_ui->dvFrequencyData->currentIndex();
int row = idx.row();
if (row < 0)
return;
CnrConfig cnrConfigRow = m_frequencyDataModel->itemData(idx).cnrConfig;
int cnrConfigId = cnrConfigRow.id();
if (cnrConfigId <= 0)
return;
unassignRadioCircuit(cnrConfigId);
CnrConfig cnrConfigRow = m_frequencyDataModel->itemData(idx).cnrConfig;
int cnrConfigId = cnrConfigRow.id();
if (cnrConfigId <= 0)
return;
unassignRadioCircuit(cnrConfigId);
}
void EditFrequencyPlanningDialog::enableSelectedUnassignButton()
{
QModelIndex idx = m_ui->dvFrequencyData->currentIndex();
int row = idx.row();
if (row < 0)
return;
QModelIndex idx = m_ui->dvFrequencyData->currentIndex();
int row = idx.row();
if (row < 0)
return;
auto itemData = m_frequencyDataModel->itemData(idx);
CnrConfig cnrConfigRow = itemData.cnrConfig;
int cnrConfigId = cnrConfigRow.id();
if (cnrConfigId <= 0)
return;
auto itemData = m_frequencyDataModel->itemData(idx);
CnrConfig cnrConfigRow = itemData.cnrConfig;
int cnrConfigId = cnrConfigRow.id();
if (cnrConfigId <= 0)
return;
FrequencyPlanningData fpd = m_frequencyDataModel->getfrequencyPlanningData(cnrConfigId);
FrequencyPlanningData fpd = m_frequencyDataModel->getfrequencyPlanningData(cnrConfigId);
QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, true);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, true);
if( (!cnrConfigRow.exerciseId().is_set()
&& m_planning.exerciseId().is_set())
||
itemData.readOnly
)
{
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Show"));
m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Show;
if (circuits.size() == 0)
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, false);
}
else if (circuits.size() > 0)
{
m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Edit;
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Edit"));
}
else
{
m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Assign;
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Assign"));
}
if ((!cnrConfigRow.exerciseId().is_set() && m_planning.exerciseId().is_set()) || itemData.readOnly)
{
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Show"));
m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Show;
if (circuits.size() == 0)
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, false);
}
else if (circuits.size() > 0)
{
m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Edit;
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Edit"));
}
else
{
m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Assign;
m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Assign"));
}
DEBUG_LOG(m_logger) << "---enableAssignUnassignButtons()...."
<< " cnrConfigId: " << cnrConfigId
<< " radioCircuitId: " << cnrConfigRow.radioCircuit();
DEBUG_LOG(m_logger) << "---enableAssignUnassignButtons()...."
<< " cnrConfigId: " << cnrConfigId << " radioCircuitId: " << cnrConfigRow.radioCircuit();
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, !itemData.readOnly && m_isEdit == EditFrequencyPlanningSetResourceDialog::DialogMode::Edit);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove,
!itemData.readOnly &&
m_isEdit == EditFrequencyPlanningSetResourceDialog::DialogMode::Edit);
qDeleteAll(circuits);
qDeleteAll(circuits);
}
void EditFrequencyPlanningDialog::onAssignRadioCircuit(const FrequencyPlanningData &fpd)
void EditFrequencyPlanningDialog::onAssignRadioCircuit(const FrequencyPlanningData& fpd)
{
DEBUG_LOG(m_logger) << "---onAssignRadioCircuit()...."
<< "CnrConfigId: " << fpd.cnrConfigId();
<< "CnrConfigId: " << fpd.cnrConfigId();
m_frequencyDataModel->setFrequencyPlanningData(fpd);
if (!m_frequencyDataModel->checkResourceAssignments())
{
focusDialog(m_menuGroup, m_freqPlanningDialogIdentifier, LtsWidgets::LayoutArea::eDialogTab);
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Multiple assignments with the same resource are not possible. Please correct the selected entries."));
return;
}
enableSelectedUnassignButton();
slotChangesMade();
m_ui->dvFrequencyData->repaint();
m_ui->dvFrequencyData->expandAll();
m_frequencyDataModel->setFrequencyPlanningData(fpd);
if (!m_frequencyDataModel->checkResourceAssignments())
{
focusDialog(m_menuGroup, m_freqPlanningDialogIdentifier, LtsWidgets::LayoutArea::eDialogTab);
LtsWidgets::LtsMessageDialog::showMessage(
this,
tr("Multiple assignments with the same resource are not possible. Please correct the selected entries."));
return;
}
enableSelectedUnassignButton();
slotChangesMade();
m_ui->dvFrequencyData->repaint();
m_ui->dvFrequencyData->expandAll();
}
void EditFrequencyPlanningDialog::onPrint()
{
LtsPrinting::printView(m_session, this, m_ui->dvFrequencyData->treeView() );
LtsPrinting::printView(m_session, this, m_ui->dvFrequencyData->treeView());
}
int32_t EditFrequencyPlanningDialog::currentFrequencySetId() const
{
QModelIndex currentFrequencySetDataIndex = m_ui->dvFrequencyData->currentIndex();
QModelIndex currentFrequencySetDataIndex = m_ui->dvFrequencyData->currentIndex();
if (!currentFrequencySetDataIndex.isValid())
return -1;
if (!currentFrequencySetDataIndex.isValid())
return -1;
return m_frequencyDataModel->data(currentFrequencySetDataIndex, Qt::UserRole).toInt();
return m_frequencyDataModel->data(currentFrequencySetDataIndex, Qt::UserRole).toInt();
}
QVector<int> EditFrequencyPlanningDialog::otherActiveExercises() const
{
const auto allExercises_ = m_exmDtc->exercises();
const auto allExercises_ = m_exmDtc->exercises();
Q_ASSERT(::isActive(allExercises_[m_exerciseId].state()));
Q_ASSERT(::isActive(allExercises_[m_exerciseId].state()));
auto allExercises = allExercises_.values();
auto newEnd = std::remove_if(allExercises.begin(), allExercises.end(),
[](const ExerciseManagement::Exercise& ex) { return ex.isDeleted(); });
allExercises.erase(newEnd, allExercises.end());
auto allExercises = allExercises_.values();
auto newEnd = std::remove_if(allExercises.begin(), allExercises.end(), [] (const ExerciseManagement::Exercise &ex) { return ex.isDeleted(); });
allExercises.erase(newEnd, allExercises.end());
QVector<int> toBeConsidered;
for (const auto& exercise : std::as_const(allExercises))
{
if (exercise.id() == m_exerciseId)
continue;
QVector<int> toBeConsidered;
for (const auto &exercise : std::as_const(allExercises))
{
if (exercise.id() == m_exerciseId)
continue;
if (::isActive(exercise.state()))
toBeConsidered.append(exercise.id());
}
return toBeConsidered;
if (::isActive(exercise.state()))
toBeConsidered.append(exercise.id());
}
return toBeConsidered;
}
QVector<int> EditFrequencyPlanningDialog::otherActivePlans() const
{
QVector<int> result;
QVector<int> exercises = otherActiveExercises();
QVector<int> result;
QVector<int> exercises = otherActiveExercises();
const auto activePlans = m_avmDtc->activeFrequencyPlannings();
for (const auto &activePlan : activePlans)
{
if (exercises.contains(activePlan.exerciseId()))
result.append(activePlan.frequencyPlanningId());
}
return result;
const auto activePlans = m_avmDtc->activeFrequencyPlannings();
for (const auto& activePlan : activePlans)
{
if (exercises.contains(activePlan.exerciseId()))
result.append(activePlan.frequencyPlanningId());
}
return result;
}
void EditFrequencyPlanningDialog::unassignRadioCircuit(int32_t cnrConfigId)
{
m_frequencyDataModel->unassignRadioCircuit(cnrConfigId);
enableSelectedUnassignButton();
slotChangesMade();
m_ui->dvFrequencyData->expandAll();
m_frequencyDataModel->unassignRadioCircuit(cnrConfigId);
enableSelectedUnassignButton();
slotChangesMade();
m_ui->dvFrequencyData->expandAll();
}
void EditFrequencyPlanningDialog::onExportButtonClicked()
{
QByteArray byteArray = m_frequencyDataModel->uiToJson();
int fileId = m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
if (fileId > 0)
DEBUG_LOG(m_logger) << "Saved file with id = " << fileId;
else
ERROR_LOG(m_logger) << "Could not save file in library ";
QByteArray byteArray = m_frequencyDataModel->uiToJson();
int fileId = m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
if (fileId > 0)
DEBUG_LOG(m_logger) << "Saved file with id = " << fileId;
else
ERROR_LOG(m_logger) << "Could not save file in library ";
}
void EditFrequencyPlanningDialog::onImportButtonClicked()
{
DEBUG_LOG(m_logger) << "--- onImportButtonClicked() ";
DEBUG_LOG(m_logger) << "--- onImportButtonClicked() ";
QByteArray content;
int fileId = m_flmGui->loadFileContent(this, content, {FileManagement::FileType::Xml}, m_session->exerciseId(), FileManagement::toString(FileManagement::XmlType::AVMEditFrequencyPlanning));
if (fileId > 0)
{
if (!m_flmGui->isXmlType(content, FileManagement::toString(FileManagement::XmlType::AVMEditFrequencyPlanning)))
QByteArray content;
int fileId = m_flmGui->loadFileContent(this, content, {FileManagement::FileType::Xml}, m_session->exerciseId(),
FileManagement::toString(FileManagement::XmlType::AVMEditFrequencyPlanning));
if (fileId > 0)
{
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this,
tr("Invalid xml file content"),
windowTitle(),
LtsWidgets::Behaviour::Modal,
LtsWidgets::Button::Yes,
texts);
if (!m_flmGui->isXmlType(content, FileManagement::toString(FileManagement::XmlType::AVMEditFrequencyPlanning)))
{
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Invalid xml file content"), windowTitle(),
LtsWidgets::Behaviour::Modal, LtsWidgets::Button::Yes, texts);
}
else
{
LoadFrequencyPlanningDialog loadingDialog(content, m_frequencyDataModel->toFrequencyPlanning(), m_avmDtc,
m_ismDtc);
loadingDialog.exec();
if (loadingDialog.isApplied())
{
const QVector<int> unassignments = loadingDialog.unassignments();
for (int idToUnassign : unassignments)
m_frequencyDataModel->unassignRadioCircuit(idToUnassign);
const QVector<FrequencyPlanningData> planningData = loadingDialog.newPlanningData();
for (const FrequencyPlanningData& currentData : planningData)
m_frequencyDataModel->setFrequencyPlanningData(currentData);
slotChangesMade();
m_ui->dvFrequencyData->expandAll();
}
}
}
else
{
LoadFrequencyPlanningDialog loadingDialog(content, m_frequencyDataModel->toFrequencyPlanning(), m_avmDtc, m_ismDtc) ;
loadingDialog.exec();
if (loadingDialog.isApplied())
{
const QVector<int> unassignments = loadingDialog.unassignments();
for (int idToUnassign : unassignments)
m_frequencyDataModel->unassignRadioCircuit(idToUnassign);
const QVector<FrequencyPlanningData> planningData = loadingDialog.newPlanningData();
for (const FrequencyPlanningData &currentData : planningData)
m_frequencyDataModel->setFrequencyPlanningData(currentData);
slotChangesMade();
m_ui->dvFrequencyData->expandAll();
}
}
}
}
}
} // namespace AudioVideoManagement
@@ -1,99 +1,94 @@
#include "avm_edit_frequency_planning_resource_data_model.h"
#include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
#include <AudioVideoManagement/avm_translation.h>
#include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
namespace AudioVideoManagement
{
EditFrequencyPlanningResourceDataModel::EditFrequencyPlanningResourceDataModel(const QSet<int> &assignedFrequencySetDataIds,
const FrequencyBand frequencyBand,
QObject *parent)
: LtsAbstractTableModel<FrequencySetDataWithId>(
{
tr("FSD id"),
tr("Function"),
tr("Device"),
tr("Frequency"),
tr("AKW Bundle"),
tr("FSB Bundle"),
tr("AKW Radio Circuit"),
tr("COMSEC"),
}, parent)
, m_assignedFrequencySetDataIds(assignedFrequencySetDataIds)
, m_frequencyBand(frequencyBand)
EditFrequencyPlanningResourceDataModel::EditFrequencyPlanningResourceDataModel(
const QSet<int>& assignedFrequencySetDataIds, const FrequencyBand frequencyBand, QObject* parent)
: LtsAbstractTableModel<FrequencySetDataWithId>(
{
tr("FSD id"),
tr("Function"),
tr("Device"),
tr("Frequency"),
tr("AKW Bundle"),
tr("FSB Bundle"),
tr("AKW Radio Circuit"),
tr("COMSEC"),
},
parent),
m_assignedFrequencySetDataIds(assignedFrequencySetDataIds), m_frequencyBand(frequencyBand)
{
}
QVariant EditFrequencyPlanningResourceDataModel::data(const QModelIndex &index, int role) const
QVariant EditFrequencyPlanningResourceDataModel::data(const QModelIndex& index, int role) const
{
if ((role != Qt::DisplayRole && role != Qt::UserRole) || !indexIsValid(index))
return QVariant();
if ((role != Qt::DisplayRole && role != Qt::UserRole) || !indexIsValid(index))
return QVariant();
const FrequencySetDataWithId &setData = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
QLocale locale(QLocale::German);
switch (index.column())
const FrequencySetDataWithId& setData = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
case FREQ_SET_DATA_ID:
return setData.id();
case FUNCTION:
return QString::fromStdString(setData.function());
case DEVICE:
return toString(setData.frequencyBand());
case FREQUENCY:
return tr("%1 MHz").arg(locale.toString(setData.frequency() / 1000., 'f', 3));
case AKW_BUNDLE:
if (setData.akwBundle().is_set())
return setData.akwBundle().get();
return QStringLiteral("-");
case FSB_BUNDLE:
if (setData.fsbBundle().is_set())
return setData.fsbBundle().get();
return QStringLiteral("-");
case AKW_RADIO_CIRCUIT:
if (setData.akwRadioCircuit())
return setData.akwRadioCircuit().get();
return QStringLiteral("-");
case COMSEC:
if (setData.comsec().is_set())
return setData.comsec().get();
return QStringLiteral("-");
QLocale locale(QLocale::German);
switch (index.column())
{
case FREQ_SET_DATA_ID:
return setData.id();
case FUNCTION:
return QString::fromStdString(setData.function());
case DEVICE:
return toString(setData.frequencyBand());
case FREQUENCY:
return tr("%1 MHz").arg(locale.toString(setData.frequency() / 1000., 'f', 3));
case AKW_BUNDLE:
if (setData.akwBundle().is_set())
return setData.akwBundle().get();
return QStringLiteral("-");
case FSB_BUNDLE:
if (setData.fsbBundle().is_set())
return setData.fsbBundle().get();
return QStringLiteral("-");
case AKW_RADIO_CIRCUIT:
if (setData.akwRadioCircuit())
return setData.akwRadioCircuit().get();
return QStringLiteral("-");
case COMSEC:
if (setData.comsec().is_set())
return setData.comsec().get();
return QStringLiteral("-");
}
}
}
else if (role == Qt::UserRole)
return setData.id();
else if (role == Qt::UserRole)
return setData.id();
return QVariant();
return QVariant();
}
bool EditFrequencyPlanningResourceDataModel::isFiltered(const AudioVideoManagement::FrequencySetDataWithId &data, DataModification modType) const
bool EditFrequencyPlanningResourceDataModel::isFiltered(const AudioVideoManagement::FrequencySetDataWithId& data,
DataModification modType) const
{
if (m_frequencyBand != FrequencyBand_def::REL &&
data.frequencyBand() != m_frequencyBand)
return true;
if (m_frequencyBand != FrequencyBand_def::REL && data.frequencyBand() != m_frequencyBand)
return true;
if(m_frequencyBand == FrequencyBand_def::REL &&
data.frequencyBand() != FrequencyBand_def::VHF)
return true;
if (m_frequencyBand == FrequencyBand_def::REL && data.frequencyBand() != FrequencyBand_def::VHF)
return true;
Q_UNUSED(modType);
if (m_assignedFrequencySetDataIds.contains(data.id()))
{
DEBUG_LOG(m_logger) << "---m_assignments.size(): " << m_assignedFrequencySetDataIds.size()
<< " frequencySetDataId: " << data.id() << " ist bereits enthalten";
return true;
}
Q_UNUSED(modType);
return false;
if (m_assignedFrequencySetDataIds.contains(data.id()))
{
DEBUG_LOG(m_logger) << "---m_assignments.size(): " << m_assignedFrequencySetDataIds.size()
<< " frequencySetDataId: " << data.id() << " ist bereits enthalten";
return true;
}
return false;
}
}
} // namespace AudioVideoManagement
@@ -1,491 +1,471 @@
#include "avm_frequency_planning_dialog.h"
#include "ui_avm_frequency_planning_dialog.h"
#include "avm_frequency_planning_dialog_model.h"
#include "avm_edit_frequency_planning_dialog.h"
#include "avm_frequency_planning_dialog_model.h"
#include "avm_init_frequency_planning_dialog.h"
#include "ui_avm_frequency_planning_dialog.h"
#include <InfrastructureManagement/ism_dtc.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsSession/lts_session.h>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <FileManagement/flm_translation.h>
#include <ParticipantManagement/ppm.hpp>
#include <AudioVideoManagement/avm_translation.h>
#include <LtsWidgets/lts_base_layout_widget.h>
#include <FileManagement/flm_translation.h>
#include <InfrastructureManagement/ism_dtc.h>
#include <LtsPrinting/printing.h>
#include <QTreeView>
#include <LtsSession/lts_session.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsWidgets/lts_base_layout_widget.h>
#include <ParticipantManagement/ppm.hpp>
#include <PluginInterfaces/gui_plugin_interface.h>
#include <QMessageBox>
#include <QTreeView>
namespace AudioVideoManagement
{
FrequencyPlanningDialog::FrequencyPlanningDialog(LtsSession::LtsSession *session, const QString &menuGroup, QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
, m_ui(new Ui::FrequencyPlanningDialog)
, m_menuGroup(menuGroup)
, m_copy(false)
, m_session(session)
, m_model(nullptr)
, m_requestHelper(new LtsUtils::RequestHelper(this))
, m_activePlanning( { -1, -1 })
, m_avmDtc(nullptr)
, m_avmFtc(nullptr)
, m_ppmDtc(nullptr)
, m_ismDtc(nullptr)
, m_flmGui(nullptr)
, m_activeFrequencyPlanningStatus(0)
FrequencyPlanningDialog::FrequencyPlanningDialog(LtsSession::LtsSession* session, const QString& menuGroup,
QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly), m_ui(new Ui::FrequencyPlanningDialog),
m_menuGroup(menuGroup), m_copy(false), m_session(session), m_model(nullptr),
m_requestHelper(new LtsUtils::RequestHelper(this)), m_activePlanning({-1, -1}), m_avmDtc(nullptr),
m_avmFtc(nullptr), m_ppmDtc(nullptr), m_ismDtc(nullptr), m_flmGui(nullptr), m_activeFrequencyPlanningStatus(0)
{
m_ui->setupUi(this);
m_ui->setupUi(this);
DEBUG_LOG(m_logger) << "---FrequencyPlanningDialog() ";
m_ui->dataView->setSelectionMode(QAbstractItemView::SingleSelection);
m_ui->dataView->treeView()->setSelectionBehavior(QAbstractItemView::SelectRows);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &FrequencyPlanningDialog::onPrint);
DEBUG_LOG(m_logger) << "---FrequencyPlanningDialog() ";
m_ui->dataView->setSelectionMode(QAbstractItemView::SingleSelection);
m_ui->dataView->treeView()->setSelectionBehavior(QAbstractItemView::SelectRows);
setOnlineHelpFilename(QStringLiteral("Situation-Frequency_Planning"));
m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &FrequencyPlanningDialog::onPrint);
setOnlineHelpFilename(QStringLiteral("Situation-Frequency_Planning"));
}
FrequencyPlanningDialog::~FrequencyPlanningDialog()
{
delete m_ui;
delete m_ui;
}
void FrequencyPlanningDialog::retranslate()
{
translate(m_ui, tr("Frequency Planning"));
translate(m_ui, tr("Frequency Planning"));
}
void FrequencyPlanningDialog::unsetActiveFrequencyPlanning()
{
m_ui->lbActiveFrequencyPlanning->setText(tr("No Frequency Planning set"));
m_activePlanning = { -1, -1 };
m_model->unsetActivePlanning();
onSelectionChanged();
m_ui->lbActiveFrequencyPlanning->setText(tr("No Frequency Planning set"));
m_activePlanning = {-1, -1};
m_model->unsetActivePlanning();
onSelectionChanged();
}
void FrequencyPlanningDialog::setActiveFrequencyPlanning(const ActiveFrequencyPlanning &activePlanning)
void FrequencyPlanningDialog::setActiveFrequencyPlanning(const ActiveFrequencyPlanning& activePlanning)
{
m_ui->lbActiveFrequencyPlanning->setText(QString::fromStdString(m_avmDtc->frequencyPlanning(activePlanning.frequencyPlanningId()).name()));
m_activePlanning = activePlanning;
m_model->setActivePlanning(m_activePlanning.frequencyPlanningId());
onSelectionChanged();
m_ui->lbActiveFrequencyPlanning->setText(
QString::fromStdString(m_avmDtc->frequencyPlanning(activePlanning.frequencyPlanningId()).name()));
m_activePlanning = activePlanning;
m_model->setActivePlanning(m_activePlanning.frequencyPlanningId());
onSelectionChanged();
}
bool FrequencyPlanningDialog::init(const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc> &ismDtc,
ExerciseManagement::Interface::Dtc *exmDtc)
bool FrequencyPlanningDialog::init(const std::shared_ptr<Interface::Dtc>& avmDtc,
const std::shared_ptr<Interface::Ftc>& avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc>& ismDtc,
ExerciseManagement::Interface::Dtc* exmDtc)
{
if (!(ppmDtc->enableParty() &&
ppmDtc->enableParticipant() &&
ppmDtc->enableType() &&
avmDtc->enableCnrConfig() &&
avmDtc->enableFrequencyPlanning() &&
avmDtc->enableFrequencySet() &&
avmDtc->enableActiveFrequencyPlanning() &&
ismDtc->enableMainStructureElement()))
{
ERROR_LOG(m_logger) << "Could not enable topics";
return false;
}
if (!(ppmDtc->enableParty() && ppmDtc->enableParticipant() && ppmDtc->enableType() && avmDtc->enableCnrConfig() &&
avmDtc->enableFrequencyPlanning() && avmDtc->enableFrequencySet() &&
avmDtc->enableActiveFrequencyPlanning() && ismDtc->enableMainStructureElement()))
{
ERROR_LOG(m_logger) << "Could not enable topics";
return false;
}
delete m_model;
m_model = new FrequencyPlanningDialogModel(m_session->exerciseId(), this);
m_avmDtc = avmDtc;
m_avmFtc = avmFtc;
m_ppmDtc = ppmDtc;
m_ismDtc = ismDtc;
m_exmDtc = exmDtc;
if (!m_model->init(avmDtc))
{
delete m_model;
m_model = nullptr;
ERROR_LOG(m_logger) << "Could not init model";
return false;
}
m_model = new FrequencyPlanningDialogModel(m_session->exerciseId(), this);
m_proxyModel = new FrequencyPlanningDialogProxyModel(this);
m_proxyModel->setSourceModel(m_model);
m_ui->dataView->setModel(m_proxyModel);
m_avmDtc = avmDtc;
m_avmFtc = avmFtc;
m_ppmDtc = ppmDtc;
m_ismDtc = ismDtc;
m_exmDtc = exmDtc;
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &FrequencyPlanningDialog::onAddClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &FrequencyPlanningDialog::onEditClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &FrequencyPlanningDialog::onRemoveClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Save, this, &FrequencyPlanningDialog::onActivateDeactivatePlanningClicked);
if (!m_model->init(avmDtc))
{
delete m_model;
m_model = nullptr;
ERROR_LOG(m_logger) << "Could not init model";
return false;
}
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalSelectionChanged,
this, &FrequencyPlanningDialog::onSelectionChanged);
m_proxyModel = new FrequencyPlanningDialogProxyModel(this);
m_proxyModel->setSourceModel(m_model);
m_ui->dataView->setModel(m_proxyModel);
unsetActiveFrequencyPlanning();
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &FrequencyPlanningDialog::onAddClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &FrequencyPlanningDialog::onEditClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &FrequencyPlanningDialog::onRemoveClicked);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Save, this,
&FrequencyPlanningDialog::onActivateDeactivatePlanningClicked);
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalSelectionChanged, this,
&FrequencyPlanningDialog::onSelectionChanged);
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalDoubleClicked,
this, &FrequencyPlanningDialog::onEditClicked);
connect(m_avmDtc.get(), &Interface::Dtc::activeFrequencyPlanningChanged,
this, &FrequencyPlanningDialog::onActiveFrequencyPlanningChanged);
unsetActiveFrequencyPlanning();
m_ui->dataView->hideColumn(FrequencyPlanningDialogModel::Columns::SET);
connect(m_ui->dataView, &LtsDataView::LtsDataView::signalDoubleClicked, this,
&FrequencyPlanningDialog::onEditClicked);
connect(m_avmDtc.get(), &Interface::Dtc::activeFrequencyPlanningChanged, this,
&FrequencyPlanningDialog::onActiveFrequencyPlanningChanged);
m_avmDtc->activeFrequencyPlannings([this](const ActiveFrequencyPlanning & data)
{
onActiveFrequencyPlanningChanged(data, DataModification::eAdded);
});
onSelectionChanged();
m_ui->dataView->hideColumn(FrequencyPlanningDialogModel::Columns::SET);
setStatus(tr("No active Radio Controller connected."), {}, time(0) * 1000, TransmissionReason::TR_Unknown, Qt::red);
for(auto &elem : m_avmDtc->frequencyPlanningStatuss())
{
if (!elem.isActive())
continue;
m_activeFrequencyPlanningStatus = elem.id();
onFrequencyPlanningStatusChanged(elem, DataModification::eAdded);
}
connect(m_avmDtc.get(), &Interface::Dtc::frequencyPlanningStatusChanged, this, &FrequencyPlanningDialog::onFrequencyPlanningStatusChanged);
m_avmDtc->activeFrequencyPlannings([this](const ActiveFrequencyPlanning& data) {
onActiveFrequencyPlanningChanged(data, DataModification::eAdded);
});
onSelectionChanged();
return true;
}
void FrequencyPlanningDialog::onFrequencyPlanningStatusChanged(const AudioVideoManagement::FrequencyPlanningStatus &data, DataModification modType)
{
if (modType == DataModification::eModified)
{
if (data.id() != m_activeFrequencyPlanningStatus)
return;
}
else if (modType == DataModification::eRemoved)
{
if (data.id() != m_activeFrequencyPlanningStatus)
return;
m_activeFrequencyPlanningStatus = 0;
setStatus(tr("No active Radio Controller connected."), {}, time(0) * 1000, TransmissionReason::TR_Unknown, Qt::red);
return;
}
else
{
if (!data.isActive())
return;
m_activeFrequencyPlanningStatus = data.id();
}
for (auto& elem : m_avmDtc->frequencyPlanningStatuss())
{
if (!elem.isActive())
continue;
m_activeFrequencyPlanningStatus = elem.id();
onFrequencyPlanningStatusChanged(elem, DataModification::eAdded);
}
connect(m_avmDtc.get(), &Interface::Dtc::frequencyPlanningStatusChanged, this,
&FrequencyPlanningDialog::onFrequencyPlanningStatusChanged);
if (data.activated().is_set())
{
setStatus(tr("Activated"), QString::fromStdString(data.requester()), data.activated().get(), data.reason(), Qt::green);
return;
}
if (data.received().is_set())
{
setStatus(tr("In Progress"), QString::fromStdString(data.requester()), data.received().get(), data.reason(), Qt::yellow);
return;
}
if (data.sent().is_set())
{
setStatus(tr("Sent"), QString::fromStdString(data.requester()), data.sent().get(), TransmissionReason::TR_Unknown, Qt::yellow);
return;
}
setStatus(tr("Connection established, status unknown."), {}, time(0) * 1000, TransmissionReason::TR_Unknown, Qt::yellow);
return true;
}
void FrequencyPlanningDialog::setStatus(const QString &statusText, const QString &requester, qint64 timeStampMsecs, TransmissionReason reason, Qt::GlobalColor color)
void FrequencyPlanningDialog::onFrequencyPlanningStatusChanged(
const AudioVideoManagement::FrequencyPlanningStatus& data, DataModification modType)
{
m_ui->lblStatus->setText(statusText);
m_ui->lblStatusTime->setText(DTG::toStringMSec(timeStampMsecs));
m_ui->lblStatus->setToolTip(toString(reason));
m_ui->lblStatusTime->setToolTip(requester);
setBackgroundColor(m_ui->lblStatus, color, color != Qt::black);
if (modType == DataModification::eModified)
{
if (data.id() != m_activeFrequencyPlanningStatus)
return;
}
else if (modType == DataModification::eRemoved)
{
if (data.id() != m_activeFrequencyPlanningStatus)
return;
m_activeFrequencyPlanningStatus = 0;
setStatus(tr("No active Radio Controller connected."), {}, time(0) * 1000, TransmissionReason::TR_Unknown,
Qt::red);
return;
}
else
{
if (!data.isActive())
return;
m_activeFrequencyPlanningStatus = data.id();
}
if (data.activated().is_set())
{
setStatus(tr("Activated"), QString::fromStdString(data.requester()), data.activated().get(), data.reason(),
Qt::green);
return;
}
if (data.received().is_set())
{
setStatus(tr("In Progress"), QString::fromStdString(data.requester()), data.received().get(), data.reason(),
Qt::yellow);
return;
}
if (data.sent().is_set())
{
setStatus(tr("Sent"), QString::fromStdString(data.requester()), data.sent().get(),
TransmissionReason::TR_Unknown, Qt::yellow);
return;
}
setStatus(tr("Connection established, status unknown."), {}, time(0) * 1000, TransmissionReason::TR_Unknown,
Qt::yellow);
}
void FrequencyPlanningDialog::setStatus(const QString& statusText, const QString& requester, qint64 timeStampMsecs,
TransmissionReason reason, Qt::GlobalColor color)
{
m_ui->lblStatus->setText(statusText);
m_ui->lblStatusTime->setText(DTG::toStringMSec(timeStampMsecs));
m_ui->lblStatus->setToolTip(toString(reason));
m_ui->lblStatusTime->setToolTip(requester);
setBackgroundColor(m_ui->lblStatus, color, color != Qt::black);
}
void FrequencyPlanningDialog::tableColumnOrganiserSetting()
{
m_ui->dataView->setColumnsOrganiserEnabled(identifier(), true);
m_ui->dataView->setColumnsOrganiserEnabled(identifier(), true);
}
void FrequencyPlanningDialog::setBackgroundColor(QWidget *w, Qt::GlobalColor color, bool bSetColor)
void FrequencyPlanningDialog::setBackgroundColor(QWidget* w, Qt::GlobalColor color, bool bSetColor)
{
if (!w)
return;
if (!w)
return;
if (bSetColor)
{
QPalette pal = QApplication::palette(w);
pal.setColor(QPalette::Window, color);
w->setPalette(pal);
w->setAutoFillBackground(true);
}
else
{
w->setPalette(QApplication::palette(w));
w->setAutoFillBackground(false);
}
}
void FrequencyPlanningDialog::onModifyFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onRemoveFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onRemoveActiveFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onModifyActiveFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onAddClicked()
{
const QModelIndexList selectedRows = m_ui->dataView->selectedRows();
Q_ASSERT(selectedRows.empty() || selectedRows.size() == 1);
QMap<int32_t, FrequencySet> frequencySets = m_avmDtc->frequencySets();
if (selectedRows.empty())
{
if(frequencySets.size() == 1)
if (bSetColor)
{
FrequencyPlanning planning;
planning.id(0);
if(m_session->exerciseId() != 0)
planning.exerciseId(m_session->exerciseId());
planning.frequencySetId(frequencySets.first().id());
planning.date(m_session->partitionTime());
showEditDialog(planning);
QPalette pal = QApplication::palette(w);
pal.setColor(QPalette::Window, color);
w->setPalette(pal);
w->setAutoFillBackground(true);
}
else
{
InitFrequencyPlanningDialog *initDialog = new InitFrequencyPlanningDialog(m_session, m_avmDtc, this);
connect(initDialog, &InitFrequencyPlanningDialog::newInitFrequencyPlanning,
this, &FrequencyPlanningDialog::showEditDialog);
w->setPalette(QApplication::palette(w));
w->setAutoFillBackground(false);
}
}
m_copy = false;
addDialog(initDialog, m_menuGroup, QStringLiteral("NewFrequencyPlanning"));
void FrequencyPlanningDialog::onModifyFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onRemoveFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onRemoveActiveFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onModifyActiveFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject)
{
m_requestHelper->requestReply(replyObject);
}
void FrequencyPlanningDialog::onAddClicked()
{
const QModelIndexList selectedRows = m_ui->dataView->selectedRows();
Q_ASSERT(selectedRows.empty() || selectedRows.size() == 1);
QMap<int32_t, FrequencySet> frequencySets = m_avmDtc->frequencySets();
if (selectedRows.empty())
{
if (frequencySets.size() == 1)
{
FrequencyPlanning planning;
planning.id(0);
if (m_session->exerciseId() != 0)
planning.exerciseId(m_session->exerciseId());
planning.frequencySetId(frequencySets.first().id());
planning.date(m_session->partitionTime());
showEditDialog(planning);
}
else
{
InitFrequencyPlanningDialog* initDialog = new InitFrequencyPlanningDialog(m_session, m_avmDtc, this);
connect(initDialog, &InitFrequencyPlanningDialog::newInitFrequencyPlanning, this,
&FrequencyPlanningDialog::showEditDialog);
m_copy = false;
addDialog(initDialog, m_menuGroup, QStringLiteral("NewFrequencyPlanning"));
}
}
else
{
m_copy = true;
qint64 dateOfCreation = m_session->partitionTime();
FrequencyPlanning planning = m_model->data(selectedRows.constFirst(), Qt::UserRole).value<FrequencyPlanning>();
planning.date(dateOfCreation);
showEditDialog(planning);
}
}
else
{
m_copy = true;
qint64 dateOfCreation = m_session->partitionTime();
FrequencyPlanning planning = m_model->data(selectedRows.constFirst(), Qt::UserRole).value<FrequencyPlanning>();
planning.date(dateOfCreation);
showEditDialog(planning);
}
}
void FrequencyPlanningDialog::onEditClicked()
{
QModelIndex currentIndex = m_ui->dataView->currentIndex();
QModelIndex currentIndex = m_ui->dataView->currentIndex();
if (!currentIndex.isValid())
return;
if (!currentIndex.isValid())
return;
const FrequencyPlanning &fp = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>();
DEBUG_LOG(m_logger) << "---onEditClicked() FrequencyPlanningId: " << fp.id() << " FrequencySetDataId: " << fp.frequencySetId();
const FrequencyPlanning& fp = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>();
DEBUG_LOG(m_logger) << "---onEditClicked() FrequencyPlanningId: " << fp.id()
<< " FrequencySetDataId: " << fp.frequencySetId();
m_copy = false;
showEditDialog(m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>());
m_copy = false;
showEditDialog(m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>());
}
void FrequencyPlanningDialog::onRemoveClicked()
{
const QModelIndex currentIndex = m_ui->dataView->currentIndex();
const QModelIndex currentIndex = m_ui->dataView->currentIndex();
if (!currentIndex.isValid())
return;
if (!currentIndex.isValid())
return;
int planningId = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id();
if (m_editDlgMap.contains(planningId))
{
m_editDlgMap.value(planningId)->deleteLater();
m_editDlgMap.remove(planningId);
}
int planningId = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id();
Core::RemoveElementRequest req;
if (m_editDlgMap.contains(planningId))
{
m_editDlgMap.value(planningId)->deleteLater();
m_editDlgMap.remove(planningId);
}
req.id(planningId);
Core::RemoveElementRequest req;
m_requestHelper->startSingleRequest([this, req]()
{
return m_avmFtc->removeFrequencyPlanningRequest(req, this);
});
req.id(planningId);
m_requestHelper->startSingleRequest([this, req]() { return m_avmFtc->removeFrequencyPlanningRequest(req, this); });
}
void FrequencyPlanningDialog::onSelectionChanged()
{
const QModelIndexList selectedRows = m_ui->dataView->selectedRows();
bool hasSelection = !selectedRows.empty();
bool selectedIsActive = false;
if (hasSelection)
{
const QModelIndex currentIndex = selectedRows.constFirst();
selectedIsActive = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id() == m_activePlanning.frequencyPlanningId();
}
const QModelIndexList selectedRows = m_ui->dataView->selectedRows();
bool hasSelection = !selectedRows.empty();
bool selectedIsActive = false;
if (hasSelection)
{
const QModelIndex currentIndex = selectedRows.constFirst();
selectedIsActive = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id() ==
m_activePlanning.frequencyPlanningId();
}
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, hasSelection);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, hasSelection && !selectedIsActive);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Save, hasSelection && m_session->exerciseId() && m_session->exerciseState() == LtsWidgets::ExcState::eStarted);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, hasSelection);
if (selectedIsActive)
m_buttonBox->getButton(LtsWidgets::DialogButton::Save)->setText(tr("Deactivate"));
else
m_buttonBox->getButton(LtsWidgets::DialogButton::Save)->setText(tr("Activate"));
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, hasSelection && !selectedIsActive);
bool disableGlobalPlanning = m_session->exerciseId() == 0 && m_proxyModel->rowCount() !=0;
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, !disableGlobalPlanning);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Save,
hasSelection && m_session->exerciseId() &&
m_session->exerciseState() == LtsWidgets::ExcState::eStarted);
if (selectedIsActive)
m_buttonBox->getButton(LtsWidgets::DialogButton::Save)->setText(tr("Deactivate"));
else
m_buttonBox->getButton(LtsWidgets::DialogButton::Save)->setText(tr("Activate"));
bool disableGlobalPlanning = m_session->exerciseId() == 0 && m_proxyModel->rowCount() != 0;
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Add, !disableGlobalPlanning);
}
void FrequencyPlanningDialog::onActivateDeactivatePlanningClicked()
{
if (QMessageBox::question(this, tr("Frequency Planning"), tr("Are you sure you want to switch the active frequency planning?"),
QMessageBox::StandardButtons(QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No))
== QMessageBox::StandardButton::No)
return;
{
if (QMessageBox::question(
this, tr("Frequency Planning"), tr("Are you sure you want to switch the active frequency planning?"),
QMessageBox::StandardButtons(QMessageBox::StandardButton::Yes | QMessageBox::StandardButton::No)) ==
QMessageBox::StandardButton::No)
return;
QModelIndex currentIndex = m_ui->dataView->currentIndex();
QModelIndex currentIndex = m_ui->dataView->currentIndex();
if (!currentIndex.isValid())
return;
if (!currentIndex.isValid())
return;
int32_t planningId = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id();
int32_t planningId = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id();
bool isActive = planningId == m_activePlanning.frequencyPlanningId();
if (!isActive)
{
ModifyActiveFrequencyPlanningRequest request(m_session->exerciseId(), planningId);
m_requestHelper->startSingleRequest([this, request]()
bool isActive = planningId == m_activePlanning.frequencyPlanningId();
if (!isActive)
{
return m_avmFtc->modifyActiveFrequencyPlanningRequest(request, this);
});
}
else
{
RemoveActiveFrequencyPlanningRequest request(m_session->exerciseId());
ModifyActiveFrequencyPlanningRequest request(m_session->exerciseId(), planningId);
m_requestHelper->startSingleRequest([this, request]()
m_requestHelper->startSingleRequest(
[this, request]() { return m_avmFtc->modifyActiveFrequencyPlanningRequest(request, this); });
}
else
{
return m_avmFtc->removeActiveFrequencyPlanningRequest(request, this);
});
}
RemoveActiveFrequencyPlanningRequest request(m_session->exerciseId());
m_requestHelper->startSingleRequest(
[this, request]() { return m_avmFtc->removeActiveFrequencyPlanningRequest(request, this); });
}
}
void FrequencyPlanningDialog::showEditDialog(const FrequencyPlanning &planning)
void FrequencyPlanningDialog::showEditDialog(const FrequencyPlanning& planning)
{
QString widgetIdentifier(QStringLiteral("FrequencyPlanning%1").arg(QString::number(planning.id())));
if (m_copy)
widgetIdentifier.append(QStringLiteral("Copy"));
QString widgetIdentifier(QStringLiteral("FrequencyPlanning%1").arg(QString::number(planning.id())));
if (m_copy)
widgetIdentifier.append(QStringLiteral("Copy"));
if (baseLayoutWidget()->focusTab(menuGroup(), widgetIdentifier, LtsWidgets::LayoutArea::eDialogTab))
return;
EditFrequencyPlanningDialog *dlg = new EditFrequencyPlanningDialog(m_session, m_menuGroup, widgetIdentifier, planning, m_copy, m_avmDtc, m_avmFtc, m_ppmDtc, m_ismDtc, m_exmDtc, this);
connect(dlg, &EditFrequencyPlanningDialog::aboutToCloseMe, this , [this](int planningId)
{
if (planningId <= 0 || !m_editDlgMap.contains(planningId))
return;
m_editDlgMap.remove(planningId);
});
if (baseLayoutWidget()->focusTab(menuGroup(), widgetIdentifier, LtsWidgets::LayoutArea::eDialogTab))
return;
EditFrequencyPlanningDialog* dlg =
new EditFrequencyPlanningDialog(m_session, m_menuGroup, widgetIdentifier, planning, m_copy, m_avmDtc, m_avmFtc,
m_ppmDtc, m_ismDtc, m_exmDtc, this);
connect(dlg, &EditFrequencyPlanningDialog::aboutToCloseMe, this, [this](int planningId) {
if (planningId <= 0 || !m_editDlgMap.contains(planningId))
return;
m_editDlgMap.remove(planningId);
});
addDialog(dlg, m_menuGroup, widgetIdentifier);
addDialog(dlg, m_menuGroup, widgetIdentifier);
if (!m_copy)
{
m_editDlgMap.insert(planning.id(), dlg);
}
if (!m_copy)
{
m_editDlgMap.insert(planning.id(), dlg);
}
}
void FrequencyPlanningDialog::onActiveFrequencyPlanningChanged(const ActiveFrequencyPlanning &data, DataModification modType)
void FrequencyPlanningDialog::onActiveFrequencyPlanningChanged(const ActiveFrequencyPlanning& data,
DataModification modType)
{
if (data.exerciseId() != m_session->exerciseId())
return;
if (data.exerciseId() != m_session->exerciseId())
return;
if (modType == DataModification::eRemoved)
unsetActiveFrequencyPlanning();
else
setActiveFrequencyPlanning(data);
if (modType == DataModification::eRemoved)
unsetActiveFrequencyPlanning();
else
setActiveFrequencyPlanning(data);
}
void FrequencyPlanningDialog::onPrint()
{
LtsPrinting::printView(m_session, this, m_ui->dataView->treeView() );
LtsPrinting::printView(m_session, this, m_ui->dataView->treeView());
}
void FrequencyPlanningDialog::onExportButtonClicked()
{
QByteArray byteArray = m_model->modelToJson();
QByteArray byteArray = m_model->modelToJson();
int fileId = m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
if (fileId > 0)
DEBUG_LOG(m_logger) << "Saved file with id = " << fileId;
else
ERROR_LOG(m_logger) << "Could not save file in library ";
int fileId = m_flmGui->saveFileContent(this, FileManagement::FileType::Xml, m_session->exerciseId(), byteArray);
if (fileId > 0)
DEBUG_LOG(m_logger) << "Saved file with id = " << fileId;
else
ERROR_LOG(m_logger) << "Could not save file in library ";
}
void FrequencyPlanningDialog::onImportButtonClicked()
{
DEBUG_LOG(m_logger) << " onImportButtonClicked() ";
if (m_model->rowCount() > 0)
{
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this,
tr("Only available if the list is empty."),
windowTitle(),
LtsWidgets::Behaviour::Modal,
LtsWidgets::Button::Yes,
texts);
return;
}
DEBUG_LOG(m_logger) << " onImportButtonClicked() ";
if (m_model->rowCount() > 0)
{
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Only available if the list is empty."), windowTitle(),
LtsWidgets::Behaviour::Modal, LtsWidgets::Button::Yes, texts);
return;
}
QByteArray content;
int fileId = m_flmGui->loadFileContent(this, content, {FileManagement::FileType::Xml}, m_session->exerciseId(), FileManagement::toString(FileManagement::XmlType::AVMFrequencyPlanning));
if (fileId > 0)
{
if (!m_flmGui->isXmlType(content, FileManagement::toString(FileManagement::XmlType::AVMFrequencyPlanning)))
QByteArray content;
int fileId = m_flmGui->loadFileContent(this, content, {FileManagement::FileType::Xml}, m_session->exerciseId(),
FileManagement::toString(FileManagement::XmlType::AVMFrequencyPlanning));
if (fileId > 0)
{
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this,
tr("Invalid xml file content"),
windowTitle(),
LtsWidgets::Behaviour::Modal,
LtsWidgets::Button::Yes,
texts);
}
else
{
const QVector<ModifyFrequencyPlanningRequest> requests = m_model->jsonToFrequencyPlanningVector(content);
for (const auto &request : requests)
{
m_requestHelper->startSingleRequest([this, request]()
if (!m_flmGui->isXmlType(content, FileManagement::toString(FileManagement::XmlType::AVMFrequencyPlanning)))
{
return m_avmFtc->modifyFrequencyPlanningRequest(request, this);
});
}
INFO_LOG(m_logger) << "--- onImportButtonClicked() ";
QHash<LtsWidgets::Button, QString> texts({{LtsWidgets::Button::Yes, tr("Ok")}});
LtsWidgets::LtsMessageDialog::showMessage(this, tr("Invalid xml file content"), windowTitle(),
LtsWidgets::Behaviour::Modal, LtsWidgets::Button::Yes, texts);
}
else
{
const QVector<ModifyFrequencyPlanningRequest> requests = m_model->jsonToFrequencyPlanningVector(content);
for (const auto& request : requests)
{
m_requestHelper->startSingleRequest(
[this, request]() { return m_avmFtc->modifyFrequencyPlanningRequest(request, this); });
}
INFO_LOG(m_logger) << "--- onImportButtonClicked() ";
}
}
}
}
}
} // namespace AudioVideoManagement
@@ -1,14 +1,12 @@
#pragma once
#include <LtsWidgets/lts_dialog.h>
#include <AudioVideoManagement/logger.h>
#include <AudioVideoManagement/avm_ftc.h>
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
#include <AudioVideoManagement/logger.h>
#include <LtsUtilsCore/data_modification_enum.h>
#include <LtsWidgets/lts_dialog.h>
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
#include <memory>
namespace Ui
@@ -27,7 +25,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ParticipantManagement
namespace InfrastructureManagement
{
@@ -35,7 +33,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace InfrastructureManagement
namespace ExerciseManagement
{
@@ -43,7 +41,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace LtsSession
{
@@ -60,71 +58,70 @@ class FrequencyPlanningDialogModel;
class FrequencyPlanningDialogProxyModel;
class EditFrequencyPlanningDialog;
class FrequencyPlanningDialog
: public LtsWidgets::LtsDialog
, protected Interface::Ftc::ModifyFrequencyPlanningReplyHandler
, protected Interface::Ftc::RemoveFrequencyPlanningReplyHandler
, protected Interface::Ftc::ModifyActiveFrequencyPlanningReplyHandler
, protected Interface::Ftc::RemoveActiveFrequencyPlanningReplyHandler
class FrequencyPlanningDialog : public LtsWidgets::LtsDialog,
protected Interface::Ftc::ModifyFrequencyPlanningReplyHandler,
protected Interface::Ftc::RemoveFrequencyPlanningReplyHandler,
protected Interface::Ftc::ModifyActiveFrequencyPlanningReplyHandler,
protected Interface::Ftc::RemoveActiveFrequencyPlanningReplyHandler
{
Q_OBJECT
public:
explicit FrequencyPlanningDialog(LtsSession::LtsSession *session, const QString &menuGroup, QWidget *parent = nullptr);
~FrequencyPlanningDialog();
Q_OBJECT
public:
explicit FrequencyPlanningDialog(LtsSession::LtsSession* session, const QString& menuGroup,
QWidget* parent = nullptr);
~FrequencyPlanningDialog();
bool init(const std::shared_ptr<Interface::Dtc> &avmDtc,
const std::shared_ptr<Interface::Ftc> &avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc> &ismDtc,
ExerciseManagement::Interface::Dtc *exmDtc);
bool init(const std::shared_ptr<Interface::Dtc>& avmDtc, const std::shared_ptr<Interface::Ftc>& avmFtc,
const std::shared_ptr<ParticipantManagement::Interface::Dtc>& ppmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc>& ismDtc,
ExerciseManagement::Interface::Dtc* exmDtc);
void onModifyFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject) override final;
void onRemoveFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject) override final;
void onRemoveActiveFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject) override final;
void onModifyActiveFrequencyPlanningReply(const Core::FunctionReplyObject &replyObject) override final;
void onModifyFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject) override final;
void onRemoveFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject) override final;
void onRemoveActiveFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject) override final;
void onModifyActiveFrequencyPlanningReply(const Core::FunctionReplyObject& replyObject) override final;
private Q_SLOTS:
void onAddClicked();
void onEditClicked();
void onRemoveClicked();
void onSelectionChanged();
void onActivateDeactivatePlanningClicked();
void showEditDialog(const FrequencyPlanning &planning);
void onActiveFrequencyPlanningChanged(const ActiveFrequencyPlanning &data, DataModification modType);
void onFrequencyPlanningStatusChanged(const FrequencyPlanningStatus &data, DataModification modType);
void onPrint();
void onExportButtonClicked();
void onImportButtonClicked();
signals:
void aboutToCloseMe(int);
private Q_SLOTS:
void onAddClicked();
void onEditClicked();
void onRemoveClicked();
void onSelectionChanged();
void onActivateDeactivatePlanningClicked();
void showEditDialog(const FrequencyPlanning& planning);
void onActiveFrequencyPlanningChanged(const ActiveFrequencyPlanning& data, DataModification modType);
void onFrequencyPlanningStatusChanged(const FrequencyPlanningStatus& data, DataModification modType);
void onPrint();
void onExportButtonClicked();
void onImportButtonClicked();
signals:
void aboutToCloseMe(int);
private:
private:
NGL::INGLLogger& m_logger;
void retranslate() override;
void unsetActiveFrequencyPlanning();
void setActiveFrequencyPlanning(const ActiveFrequencyPlanning& activePlanning);
void setButtonSetActivePlanningEnabled();
static void setBackgroundColor(QWidget* w, Qt::GlobalColor color, bool bSetColor);
void setStatus(const QString& statusText, const QString& requester, qint64 timeStampMsecs,
TransmissionReason reason = TransmissionReason_def::TR_Unknown, Qt::GlobalColor color = Qt::black);
void tableColumnOrganiserSetting() override;
NGL::INGLLogger &m_logger;
void retranslate() override;
void unsetActiveFrequencyPlanning();
void setActiveFrequencyPlanning(const ActiveFrequencyPlanning &activePlanning);
void setButtonSetActivePlanningEnabled();
static void setBackgroundColor(QWidget *w, Qt::GlobalColor color, bool bSetColor);
void setStatus(const QString &statusText, const QString &requester, qint64 timeStampMsecs, TransmissionReason reason = TransmissionReason_def::TR_Unknown, Qt::GlobalColor color = Qt::black);
void tableColumnOrganiserSetting() override;
private:
Ui::FrequencyPlanningDialog *m_ui;
QString m_menuGroup;
bool m_copy;
LtsSession::LtsSession *m_session;
FrequencyPlanningDialogModel *m_model;
FrequencyPlanningDialogProxyModel *m_proxyModel;
LtsUtils::RequestHelper *m_requestHelper;
ActiveFrequencyPlanning m_activePlanning;
std::shared_ptr<Interface::Dtc> m_avmDtc;
std::shared_ptr<Interface::Ftc> m_avmFtc;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
std::shared_ptr<InfrastructureManagement::Interface::Dtc> m_ismDtc;
ExerciseManagement::Interface::Dtc *m_exmDtc;
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
QMap<int, EditFrequencyPlanningDialog*> m_editDlgMap;
int m_activeFrequencyPlanningStatus;
};
}
private:
Ui::FrequencyPlanningDialog* m_ui;
QString m_menuGroup;
bool m_copy;
LtsSession::LtsSession* m_session;
FrequencyPlanningDialogModel* m_model;
FrequencyPlanningDialogProxyModel* m_proxyModel;
LtsUtils::RequestHelper* m_requestHelper;
ActiveFrequencyPlanning m_activePlanning;
std::shared_ptr<Interface::Dtc> m_avmDtc;
std::shared_ptr<Interface::Ftc> m_avmFtc;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
std::shared_ptr<InfrastructureManagement::Interface::Dtc> m_ismDtc;
ExerciseManagement::Interface::Dtc* m_exmDtc;
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
QMap<int, EditFrequencyPlanningDialog*> m_editDlgMap;
int m_activeFrequencyPlanningStatus;
};
} // namespace AudioVideoManagement
@@ -1,197 +1,183 @@
#include "avm_frequency_planning_dialog_model.h"
#include <FileManagement/flm_translation.h>
#include <ngltools/ngltools_dtg.h>
#include <FileManagement/flm_translation.h>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <QJsonObject>
#include <ngltools/ngltools_dtg.h>
namespace AudioVideoManagement
{
FrequencyPlanningDialogModel::FrequencyPlanningDialogModel(int32_t exerciseId, QObject *parent)
: LtsAbstractTableModel<FrequencyPlanning>(
FrequencyPlanningDialogModel::FrequencyPlanningDialogModel(int32_t exerciseId, QObject* parent)
: LtsAbstractTableModel<FrequencyPlanning>({tr("Name"), tr("Date"), tr("Set"), tr("Active")}, parent),
m_exerciseId(exerciseId)
{
tr("Name"),
tr("Date"),
tr("Set"),
tr("Active")
}, parent)
, m_exerciseId(exerciseId)
{
DEBUG_LOG(m_logger) << "---FrequencyPlanningDialogModel() ";
DEBUG_LOG(m_logger) << "---FrequencyPlanningDialogModel() ";
}
QVariant FrequencyPlanningDialogModel::data(const QModelIndex &index, int role) const
QVariant FrequencyPlanningDialogModel::data(const QModelIndex& index, int role) const
{
if ((role != Qt::DisplayRole && role != Qt::UserRole) || !indexIsValid(index))
if ((role != Qt::DisplayRole && role != Qt::UserRole) || !indexIsValid(index))
return QVariant();
const FrequencyPlanning& planning = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
switch (index.column())
{
case NAME:
return QString::fromStdString(planning.name());
case DATE:
return QDateTime::fromMSecsSinceEpoch(planning.date());
case SET: {
const FrequencySet frequencySet = m_avmDtc->frequencySet(planning.frequencySetId());
return QString::fromStdString(frequencySet.name());
}
case ACTIVE:
return planning.id() == m_activePlanningId ? tr("Active") : QStringLiteral("-");
}
}
else if (role == Qt::UserRole)
return QVariant::fromValue(planning);
return QVariant();
const FrequencyPlanning &planning = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
switch (index.column())
{
case NAME:
return QString::fromStdString(planning.name());
case DATE:
return QDateTime::fromMSecsSinceEpoch(planning.date());
case SET:
{
const FrequencySet frequencySet = m_avmDtc->frequencySet(planning.frequencySetId());
return QString::fromStdString(frequencySet.name());
}
case ACTIVE:
return planning.id() == m_activePlanningId ? tr("Active") : QStringLiteral("-");
}
}
else if (role == Qt::UserRole)
return QVariant::fromValue(planning);
return QVariant();
}
bool FrequencyPlanningDialogModel::init(const std::shared_ptr<Interface::Dtc> &avmDtc)
bool FrequencyPlanningDialogModel::init(const std::shared_ptr<Interface::Dtc>& avmDtc)
{
m_avmDtc = avmDtc;
m_avmDtc = avmDtc;
m_frequencySets = m_avmDtc->frequencySets();
m_frequencySets = m_avmDtc->frequencySets();
connect(m_avmDtc.get(), &AudioVideoManagement::Interface::Dtc::frequencyPlanningChanged,
this, &FrequencyPlanningDialogModel::onFrequencyPlanningChanged);
connect(m_avmDtc.get(), &AudioVideoManagement::Interface::Dtc::frequencyPlanningChanged, this,
&FrequencyPlanningDialogModel::onFrequencyPlanningChanged);
m_avmDtc->frequencyPlannings([this](const FrequencyPlanning & p)
{
if (p.exerciseId().is_set() && p.exerciseId().get() == m_exerciseId)
insertRow(p);
});
m_avmDtc->frequencyPlannings([this](const FrequencyPlanning& p) {
if (p.exerciseId().is_set() && p.exerciseId().get() == m_exerciseId)
insertRow(p);
});
return true;
return true;
}
FrequencySet FrequencyPlanningDialogModel::frequencySetByIndex(const QModelIndex &index) const
FrequencySet FrequencyPlanningDialogModel::frequencySetByIndex(const QModelIndex& index) const
{
if (!indexIsValid(index))
return FrequencySet();
if (!indexIsValid(index))
return FrequencySet();
return m_frequencySets.value(m_vecData.at(index.row()).frequencySetId());
return m_frequencySets.value(m_vecData.at(index.row()).frequencySetId());
}
void FrequencyPlanningDialogModel::onFrequencyPlanningChanged(const FrequencyPlanning &data, DataModification modType)
void FrequencyPlanningDialogModel::onFrequencyPlanningChanged(const FrequencyPlanning& data, DataModification modType)
{
INFO_LOG(m_logger) << "onFrequencyPlanningChanged "
<< " data.exerciseId()" << data.exerciseId()
<< " m_exerciseId=" << m_exerciseId;
if ((data.exerciseId().is_set() && data.exerciseId().get() != m_exerciseId)
|| (!data.exerciseId().is_set() && m_exerciseId != 0))
return;
INFO_LOG(m_logger) << "onFrequencyPlanningChanged "
<< " data.exerciseId()" << data.exerciseId() << " m_exerciseId=" << m_exerciseId;
if ((data.exerciseId().is_set() && data.exerciseId().get() != m_exerciseId) ||
(!data.exerciseId().is_set() && m_exerciseId != 0))
return;
onDataChanged(data, modType);
onDataChanged(data, modType);
}
QByteArray FrequencyPlanningDialogModel::modelToJson()
{
QJsonObject obj;
QJsonArray arr;
QJsonArray arrData;
QJsonObject obj;
QJsonArray arr;
QJsonArray arrData;
for (int row = 0; row < rowCount(); row++)
{
DEBUG_LOG(m_logger) << "row =" << ": " << row;
QJsonObject inner;
const FrequencyPlanning &planning = m_vecData.at(row);
inner[QStringLiteral("id")] = planning.id();
inner[QStringLiteral("name")] = QString::fromStdString(planning.name());
inner[QStringLiteral("dateOfCreation")] = planning.date();
if(planning.exerciseId().is_set())
for (int row = 0; row < rowCount(); row++)
{
inner[QStringLiteral("exerciseId")] = planning.exerciseId().get();
DEBUG_LOG(m_logger) << "row =" << ": " << row;
QJsonObject inner;
const FrequencyPlanning& planning = m_vecData.at(row);
inner[QStringLiteral("id")] = planning.id();
inner[QStringLiteral("name")] = QString::fromStdString(planning.name());
inner[QStringLiteral("dateOfCreation")] = planning.date();
if (planning.exerciseId().is_set())
{
inner[QStringLiteral("exerciseId")] = planning.exerciseId().get();
}
inner[QStringLiteral("frequencySetId")] = planning.frequencySetId();
arrData = {};
for (const FrequencyPlanningData& planningData : planning.data())
{
QJsonObject innerData;
innerData[QStringLiteral("cnrConfigId")] = planningData.cnrConfigId();
innerData[QStringLiteral("properties")] = QString::fromStdString(planningData.properties());
arrData += innerData;
}
inner[QStringLiteral("data")] = arrData;
arr += inner;
}
inner[QStringLiteral("frequencySetId")] = planning.frequencySetId();
arrData = {};
for (const FrequencyPlanningData &planningData : planning.data())
{
QJsonObject innerData;
innerData[QStringLiteral("cnrConfigId")] = planningData.cnrConfigId();
innerData[QStringLiteral("properties")] = QString::fromStdString(planningData.properties());
arrData += innerData;
}
inner[QStringLiteral("data")] = arrData;
arr += inner;
}
obj[QStringLiteral("XmlType")] = FileManagement::toString(FileManagement::XmlType::AVMFrequencyPlanning);
obj[QStringLiteral("FrequencyPlanning")] = arr;
QJsonDocument doc(obj);
return doc.toJson(QJsonDocument::Compact);
obj[QStringLiteral("XmlType")] = FileManagement::toString(FileManagement::XmlType::AVMFrequencyPlanning);
obj[QStringLiteral("FrequencyPlanning")] = arr;
QJsonDocument doc(obj);
return doc.toJson(QJsonDocument::Compact);
}
QVector<ModifyFrequencyPlanningRequest> FrequencyPlanningDialogModel::jsonToFrequencyPlanningVector(const QByteArray &content)
QVector<ModifyFrequencyPlanningRequest>
FrequencyPlanningDialogModel::jsonToFrequencyPlanningVector(const QByteArray& content)
{
QVector<ModifyFrequencyPlanningRequest> result;
const QJsonDocument doc(QJsonDocument::fromJson(content));
const QJsonObject toplevelObj(doc.object());
const QJsonArray arr(toplevelObj.value(QStringLiteral("FrequencyPlanning")).toArray());
for (const auto &ele : arr)
{
const QJsonObject obj(ele.toObject());
ModifyFrequencyPlanningRequest frequencyPlanning;
frequencyPlanning.date(obj[QStringLiteral("dateOfCreation")].toDouble());
frequencyPlanning.exerciseId(m_exerciseId);
frequencyPlanning.frequencySetId(obj[QStringLiteral("frequencySetId")].toInt());
frequencyPlanning.id(0);
frequencyPlanning.name(obj[QStringLiteral("name")].toString().toStdString());
const QJsonArray arrData = (obj.value(QStringLiteral("data")).toArray());
frequencyPlanning.data().reserve(arrData.size());
for (const auto &eleData : arrData)
QVector<ModifyFrequencyPlanningRequest> result;
const QJsonDocument doc(QJsonDocument::fromJson(content));
const QJsonObject toplevelObj(doc.object());
const QJsonArray arr(toplevelObj.value(QStringLiteral("FrequencyPlanning")).toArray());
for (const auto& ele : arr)
{
const QJsonObject objData(eleData.toObject());
FrequencyPlanningData frequencyPlanningData;
frequencyPlanningData.cnrConfigId(objData[QStringLiteral("cnrConfigId")].toInt());
frequencyPlanningData.properties(objData[QStringLiteral("properties")].toString().toStdString());
frequencyPlanning.data().push_back(frequencyPlanningData);
const QJsonObject obj(ele.toObject());
ModifyFrequencyPlanningRequest frequencyPlanning;
frequencyPlanning.date(obj[QStringLiteral("dateOfCreation")].toDouble());
frequencyPlanning.exerciseId(m_exerciseId);
frequencyPlanning.frequencySetId(obj[QStringLiteral("frequencySetId")].toInt());
frequencyPlanning.id(0);
frequencyPlanning.name(obj[QStringLiteral("name")].toString().toStdString());
const QJsonArray arrData = (obj.value(QStringLiteral("data")).toArray());
frequencyPlanning.data().reserve(arrData.size());
for (const auto& eleData : arrData)
{
const QJsonObject objData(eleData.toObject());
FrequencyPlanningData frequencyPlanningData;
frequencyPlanningData.cnrConfigId(objData[QStringLiteral("cnrConfigId")].toInt());
frequencyPlanningData.properties(objData[QStringLiteral("properties")].toString().toStdString());
frequencyPlanning.data().push_back(frequencyPlanningData);
}
result.push_back(std::move(frequencyPlanning));
}
result.push_back(std::move(frequencyPlanning));
}
return result;
return result;
}
void FrequencyPlanningDialogProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
void FrequencyPlanningDialogProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
{
m_sourceModel = qobject_cast<FrequencyPlanningDialogModel*>(sourceModel);
LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
m_sourceModel = qobject_cast<FrequencyPlanningDialogModel*>(sourceModel);
LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
}
bool FrequencyPlanningDialogProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
bool FrequencyPlanningDialogProxyModel::lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const
{
if (!m_sourceModel ||
source_left.column() != source_right.column() ||
!source_left.isValid() ||
!source_right.isValid())
if (!m_sourceModel || source_left.column() != source_right.column() || !source_left.isValid() ||
!source_right.isValid())
return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
const auto& dataLeft = m_sourceModel->m_vecData.at(source_left.row());
const auto dataRight = m_sourceModel->m_vecData.at(source_right.row());
switch (source_left.column())
{
case FrequencyPlanningDialogModel::DATE:
return dataLeft.date() < dataRight.date();
case FrequencyPlanningDialogModel::NAME:
case FrequencyPlanningDialogModel::SET:
case FrequencyPlanningDialogModel::ACTIVE:
case FrequencyPlanningDialogModel::COUNT:
break;
}
return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
const auto &dataLeft = m_sourceModel->m_vecData.at(source_left.row());
const auto dataRight = m_sourceModel->m_vecData.at(source_right.row());
switch (source_left.column())
{
case FrequencyPlanningDialogModel::DATE:
return dataLeft.date() < dataRight.date();
case FrequencyPlanningDialogModel::NAME:
case FrequencyPlanningDialogModel::SET:
case FrequencyPlanningDialogModel::ACTIVE:
case FrequencyPlanningDialogModel::COUNT:
break;
}
return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
}
}
} // namespace AudioVideoManagement
@@ -1,73 +1,71 @@
#pragma once
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/logger.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
#include <AudioVideoManagement/logger.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <boost/optional.hpp>
#include <memory>
namespace AudioVideoManagement
{
class FrequencyPlanningDialogModel final
: public LtsWidgets::LtsAbstractTableModel<FrequencyPlanning>
class FrequencyPlanningDialogModel final : public LtsWidgets::LtsAbstractTableModel<FrequencyPlanning>
{
Q_OBJECT
Q_OBJECT
public:
enum Columns
{
NAME,
DATE,
SET,
ACTIVE,
COUNT
};
public:
enum Columns { NAME, DATE, SET, ACTIVE, COUNT };
explicit FrequencyPlanningDialogModel(int32_t exerciseId, QObject *parent = nullptr);
explicit FrequencyPlanningDialogModel(int32_t exerciseId, QObject* parent = nullptr);
QVariant data(const QModelIndex &index, int role) const override final;
QVariant data(const QModelIndex& index, int role) const override final;
bool init(const std::shared_ptr<Interface::Dtc> &avmDtc);
bool init(const std::shared_ptr<Interface::Dtc>& avmDtc);
void setActivePlanning(int activePlanningId) { m_activePlanningId = activePlanningId; }
void unsetActivePlanning() { m_activePlanningId.reset(); }
void setActivePlanning(int activePlanningId)
{
m_activePlanningId = activePlanningId;
}
FrequencySet frequencySetByIndex(const QModelIndex &index) const;
QByteArray modelToJson();
QVector<ModifyFrequencyPlanningRequest> jsonToFrequencyPlanningVector(const QByteArray &content);
void unsetActivePlanning()
{
m_activePlanningId.reset();
}
private Q_SLOTS:
void onFrequencyPlanningChanged(const FrequencyPlanning &data, DataModification modType);
FrequencySet frequencySetByIndex(const QModelIndex& index) const;
QByteArray modelToJson();
QVector<ModifyFrequencyPlanningRequest> jsonToFrequencyPlanningVector(const QByteArray& content);
private:
private Q_SLOTS:
void onFrequencyPlanningChanged(const FrequencyPlanning& data, DataModification modType);
NGL::INGLLogger &m_logger;
int32_t m_exerciseId;
boost::optional<int> m_activePlanningId;
std::shared_ptr<Interface::Dtc> m_avmDtc;
private:
NGL::INGLLogger& m_logger;
int32_t m_exerciseId;
boost::optional<int> m_activePlanningId;
std::shared_ptr<Interface::Dtc> m_avmDtc;
QMap<int32_t, FrequencySet> m_frequencySets;
QMap<int32_t, FrequencySet> m_frequencySets;
friend class FrequencyPlanningDialogProxyModel;
};
friend class FrequencyPlanningDialogProxyModel;
};
class FrequencyPlanningDialogProxyModel final : public LtsWidgets::LtsColumnFilterProxyModel
{
Q_OBJECT
public:
using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
void setSourceModel(QAbstractItemModel *sourceModel) override;
protected:
bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
private:
FrequencyPlanningDialogModel *m_sourceModel = nullptr;
Q_OBJECT
public:
using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
void setSourceModel(QAbstractItemModel* sourceModel) override;
protected:
bool lessThan(const QModelIndex& source_left, const QModelIndex& source_right) const override;
private:
FrequencyPlanningDialogModel* m_sourceModel = nullptr;
};
}
} // namespace AudioVideoManagement
Q_DECLARE_METATYPE(AudioVideoManagement::FrequencyPlanning)
@@ -1,238 +1,231 @@
#include "avm_frequency_planning_widget.h"
#include <LtsWidgets/lts_spinbox.h>
#include "ui_avm_frequency_planning_widget.h"
#include "avm_edit_frequency_planning_set_resource_dialog.h"
#include "avm_radio_specifica_hf_widget.h"
#include "avm_radio_specifica_vhf_widget.h"
#include "avm_radio_specifica_uhf_widget.h"
#include "avm_radio_specifica_vhf_widget.h"
#include "ui_avm_frequency_planning_widget.h"
#include <AudioVideoManagement/avm_translation.h>
#include <InfrastructureManagement/Gui/IsmComboBox/ism_combobox_gui_plugin.h>
#include <LtsWidgets/lts_spinbox.h>
#include <QJsonArray>
namespace AudioVideoManagement
{
FrequencyPlanningWidget::FrequencyPlanningWidget(const std::shared_ptr<Interface::Dtc> &avmDtc, QSet<int> &allocatedDataSets, QWidget *parent) : QWidget(parent)
, m_ui(new Ui::FrequencyPlanningWidget)
, m_assignedFrequencySetDataIds(allocatedDataSets)
, m_avmDtc(avmDtc),
m_logger(NGL::NGLLoggerBootstrap::getLogger()) {
m_ui->setupUi(this);
FrequencyPlanningWidget::FrequencyPlanningWidget(const std::shared_ptr<Interface::Dtc>& avmDtc,
QSet<int>& allocatedDataSets, QWidget* parent)
: QWidget(parent), m_ui(new Ui::FrequencyPlanningWidget), m_assignedFrequencySetDataIds(allocatedDataSets),
m_avmDtc(avmDtc), m_logger(NGL::NGLLoggerBootstrap::getLogger())
{
m_ui->setupUi(this);
m_ui->cbFrequencyBand->addItem(toString(FrequencyBand_def::VHF), FrequencyBand_def::VHF);
m_ui->cbFrequencyBand->addItem(toString(FrequencyBand_def::HF), FrequencyBand_def::HF);
m_ui->cbFrequencyBand->addItem(toString(FrequencyBand_def::UHF), FrequencyBand_def::UHF);
m_ui->cbFrequencyBand->addItem(toString(FrequencyBand_def::VHF), FrequencyBand_def::VHF);
m_ui->cbFrequencyBand->addItem(toString(FrequencyBand_def::HF), FrequencyBand_def::HF);
m_ui->cbFrequencyBand->addItem(toString(FrequencyBand_def::UHF), FrequencyBand_def::UHF);
connect(m_ui->leName, &QLineEdit::textChanged,
this, &FrequencyPlanningWidget::onNameChanged);
connect(m_ui->cbFrequencyBand, qOverload<int>(&QComboBox::currentIndexChanged),
this, &FrequencyPlanningWidget::onFrequencyBandChanged);
connect(m_avmDtc.get(), &AudioVideoManagement::Interface::Dtc::cnrConfigChanged,
this, &FrequencyPlanningWidget::onCnrConfigChanged);
connect(m_ui->leName, &QLineEdit::textChanged, this, &FrequencyPlanningWidget::onNameChanged);
connect(m_ui->cbFrequencyBand, qOverload<int>(&QComboBox::currentIndexChanged), this,
&FrequencyPlanningWidget::onFrequencyBandChanged);
connect(m_avmDtc.get(), &AudioVideoManagement::Interface::Dtc::cnrConfigChanged, this,
&FrequencyPlanningWidget::onCnrConfigChanged);
}
bool FrequencyPlanningWidget::init(LtsSession::LtsSession *session, RadioCircuit *data, const CnrConfig &cnrConfigId, int frequencySetId, FrequencyBand ft)
bool FrequencyPlanningWidget::init(LtsSession::LtsSession* session, RadioCircuit* data, const CnrConfig& cnrConfigId,
int frequencySetId, FrequencyBand ft)
{
m_frequencySetId = frequencySetId;
m_cnrConfigId = cnrConfigId.id();
m_hasParty = cnrConfigId.partyId() != 0;
m_frequencySetId = frequencySetId;
m_cnrConfigId = cnrConfigId.id();
m_hasParty = cnrConfigId.partyId() != 0;
if (!session->getForeignGuiInterface<InfrastructureManagement::ForeignGuiComboboxInterface>(m_ismCbxIfc))
return false;
m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(ft.underlying()));
m_ui->cbFrequencyBand->setVisible(false);
m_ui->lbxFrequencyBand->setVisible(false);
switch (ft.underlying())
{
case FrequencyBand_def::HF:
{
createHFWidget(data);
break;
}
case FrequencyBand_def::UHF:
{
createUHFWidget(data);
break;
}
case FrequencyBand_def::VHF:
{
createVHFWidget(data);
break;
}
default:
{
ft = data ? data->freqBand : FrequencyBand::VHF;
m_isRelay = true;
if (!session->getForeignGuiInterface<InfrastructureManagement::ForeignGuiComboboxInterface>(m_ismCbxIfc))
return false;
m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(ft.underlying()));
m_ui->cbFrequencyBand->setVisible(true);
m_ui->lbxFrequencyBand->setVisible(true);
m_ui->cbFrequencyBand->setVisible(false);
m_ui->lbxFrequencyBand->setVisible(false);
switch (ft.underlying())
{
case FrequencyBand_def::HF:
createHFWidget(data);
break;
case FrequencyBand_def::UHF:
createUHFWidget(data);
break;
case FrequencyBand_def::VHF:
createVHFWidget(data);
break;
default:
break;
break;
case FrequencyBand_def::HF: {
createHFWidget(data);
break;
}
case FrequencyBand_def::UHF: {
createUHFWidget(data);
break;
}
case FrequencyBand_def::VHF: {
createVHFWidget(data);
break;
}
default: {
ft = data ? data->freqBand : FrequencyBand::VHF;
m_isRelay = true;
m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(ft.underlying()));
m_ui->cbFrequencyBand->setVisible(true);
m_ui->lbxFrequencyBand->setVisible(true);
switch (ft.underlying())
{
case FrequencyBand_def::HF:
createHFWidget(data);
break;
case FrequencyBand_def::UHF:
createUHFWidget(data);
break;
case FrequencyBand_def::VHF:
createVHFWidget(data);
break;
default:
break;
break;
}
}
}
}
}
m_ismCbxIfc->fillRadioStationsComboBox(m_ui->cbRadioStation, ft.underlying());
if (m_hasParty && !m_isRelay)
m_ui->cbRadioStation->addItem(tr("Automatic"), 0);
if (!data)
m_ui->leName->clear();
else
{
m_ui->leName->setText(data->name);
m_ui->cbRadioStation->setCurrentIndex(m_ui->cbRadioStation->findData(data->radioStationId));
}
m_ismCbxIfc->fillRadioStationsComboBox(m_ui->cbRadioStation, ft.underlying());
if (m_hasParty && !m_isRelay)
m_ui->cbRadioStation->addItem(tr("Automatic"), 0);
if (!data)
m_ui->leName->clear();
else
{
m_ui->leName->setText(data->name);
m_ui->cbRadioStation->setCurrentIndex(m_ui->cbRadioStation->findData(data->radioStationId));
}
adjustSize();
return true;
adjustSize();
return true;
}
void FrequencyPlanningWidget::setNameDisabled(bool disable)
{
m_ui->leName->setDisabled(disable);
m_ui->leName->setDisabled(disable);
}
void FrequencyPlanningWidget::setName(const QString &name)
void FrequencyPlanningWidget::setName(const QString& name)
{
m_ui->leName->setText(name);
m_ui->leName->setText(name);
}
void FrequencyPlanningWidget::setRelaisRestrictions(bool restrict)
{
if (restrict)
{
m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(FrequencyBand_def::VHF));
m_ui->cbFrequencyBand->setEnabled(false);
}
else
{
m_ui->cbFrequencyBand->setEnabled(true);
}
if (restrict)
{
m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(FrequencyBand_def::VHF));
m_ui->cbFrequencyBand->setEnabled(false);
}
else
{
m_ui->cbFrequencyBand->setEnabled(true);
}
}
QJsonObject FrequencyPlanningWidget::toJson() const
{
return frequencyPlanningJson(m_radioSpecificaWidget->toJson(),
m_ui->leName->text(),
static_cast<FrequencyBand::inner_enum>(m_ui->cbFrequencyBand->currentData().toInt()),
m_ui->cbRadioStation->currentData().toInt());
return frequencyPlanningJson(m_radioSpecificaWidget->toJson(), m_ui->leName->text(),
static_cast<FrequencyBand::inner_enum>(m_ui->cbFrequencyBand->currentData().toInt()),
m_ui->cbRadioStation->currentData().toInt());
}
QVector<QPair<QLabel *, const std::function<bool ()> > > FrequencyPlanningWidget::requirements() const
QVector<QPair<QLabel*, const std::function<bool()>>> FrequencyPlanningWidget::requirements() const
{
return m_radioSpecificaWidget->requirements();
return m_radioSpecificaWidget->requirements();
}
FrequencyPlanningWidget::~FrequencyPlanningWidget()
{
if(m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
delete m_ui;
if (m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
delete m_ui;
}
void FrequencyPlanningWidget::onFrequencyBandChanged()
{
switch (m_ui->cbFrequencyBand->currentData().toInt())
{
case FrequencyBand_def::HF:
createHFWidget();
break;
case FrequencyBand_def::UHF:
createUHFWidget();
break;
case FrequencyBand_def::VHF:
createVHFWidget();
break;
}
switch (m_ui->cbFrequencyBand->currentData().toInt())
{
case FrequencyBand_def::HF:
createHFWidget();
break;
case FrequencyBand_def::UHF:
createUHFWidget();
break;
case FrequencyBand_def::VHF:
createVHFWidget();
break;
}
m_ui->cbRadioStation->clear();
m_ismCbxIfc->fillRadioStationsComboBox(m_ui->cbRadioStation, m_ui->cbFrequencyBand->currentData().toInt());
if(m_hasParty && !m_isRelay)
m_ui->cbRadioStation->addItem(tr("Automatic"), 0);
m_ui->cbRadioStation->clear();
m_ismCbxIfc->fillRadioStationsComboBox(m_ui->cbRadioStation, m_ui->cbFrequencyBand->currentData().toInt());
if (m_hasParty && !m_isRelay)
m_ui->cbRadioStation->addItem(tr("Automatic"), 0);
if(m_radioSpecificaWidget)
m_ui->gridLayout->addWidget(m_radioSpecificaWidget,5,0,1,2);
adjustSize();
if (m_radioSpecificaWidget)
m_ui->gridLayout->addWidget(m_radioSpecificaWidget, 5, 0, 1, 2);
adjustSize();
}
void FrequencyPlanningWidget::createHFWidget(RadioCircuit* circuit)
{
if(m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
m_radioSpecificaWidget = new RadioSpecificaHfWidget(m_ui->radioSpecificaWidget);
if(!circuit)
return;
RadioCircuitHF *dataHf = dynamic_cast<RadioCircuitHF*>(circuit);
m_radioSpecificaWidget->setValues(dataHf);
if (m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
m_radioSpecificaWidget = new RadioSpecificaHfWidget(m_ui->radioSpecificaWidget);
if (!circuit)
return;
RadioCircuitHF* dataHf = dynamic_cast<RadioCircuitHF*>(circuit);
m_radioSpecificaWidget->setValues(dataHf);
}
void FrequencyPlanningWidget::createUHFWidget(RadioCircuit* circuit)
{
if(m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
m_radioSpecificaWidget = new RadioSpecificaUhfWidget(m_ui->radioSpecificaWidget);
if(!circuit)
return;
RadioCircuitUHF* dataUhf = dynamic_cast<RadioCircuitUHF*>(circuit);
m_radioSpecificaWidget->setValues(dataUhf);
if (m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
m_radioSpecificaWidget = new RadioSpecificaUhfWidget(m_ui->radioSpecificaWidget);
if (!circuit)
return;
RadioCircuitUHF* dataUhf = dynamic_cast<RadioCircuitUHF*>(circuit);
m_radioSpecificaWidget->setValues(dataUhf);
}
void FrequencyPlanningWidget::createVHFWidget(RadioCircuit* circuit)
{
if(m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
auto *widget = new RadioSpecificaVhfWidget(m_assignedFrequencySetDataIds, m_ui->radioSpecificaWidget);
widget->init(m_frequencySetId, m_avmDtc, m_cnrConfigId);
m_radioSpecificaWidget = widget;
if (m_radioSpecificaWidget)
{
delete m_radioSpecificaWidget;
m_radioSpecificaWidget = nullptr;
}
auto* widget = new RadioSpecificaVhfWidget(m_assignedFrequencySetDataIds, m_ui->radioSpecificaWidget);
widget->init(m_frequencySetId, m_avmDtc, m_cnrConfigId);
m_radioSpecificaWidget = widget;
if(!circuit)
return;
RadioCircuitVHF* dataVhf = dynamic_cast<RadioCircuitVHF*>(circuit);
m_radioSpecificaWidget->setValues(dataVhf);
if (!circuit)
return;
RadioCircuitVHF* dataVhf = dynamic_cast<RadioCircuitVHF*>(circuit);
m_radioSpecificaWidget->setValues(dataVhf);
}
void FrequencyPlanningWidget::onCnrConfigChanged(const AudioVideoManagement::CnrConfig &config, DataModification modType)
void FrequencyPlanningWidget::onCnrConfigChanged(const AudioVideoManagement::CnrConfig& config,
DataModification modType)
{
Q_UNUSED(modType);
if (m_cnrConfigId == config.id())
{
m_ui->leName->setText(QString::fromStdString(config.radioCircuit()));
}
Q_UNUSED(modType);
if (m_cnrConfigId == config.id())
{
m_ui->leName->setText(QString::fromStdString(config.radioCircuit()));
}
}
}
} // namespace AudioVideoManagement
@@ -1,70 +1,66 @@
#include "avm_init_frequency_planning_dialog.h"
#include "ui_avm_init_frequency_planning_dialog.h"
#include <LtsSession/lts_session.h>
#include <ngltools/ngltools_dtg.h>
namespace AudioVideoManagement
{
InitFrequencyPlanningDialog::InitFrequencyPlanningDialog(LtsSession::LtsSession *session, const std::shared_ptr<Interface::Dtc> &avmDtc, QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkCancel)
, m_ui(new Ui::InitFrequencyPlanningDialog)
, m_dateOfCreation(session->partitionTime())
, m_session(session)
InitFrequencyPlanningDialog::InitFrequencyPlanningDialog(LtsSession::LtsSession* session,
const std::shared_ptr<Interface::Dtc>& avmDtc, QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkCancel), m_ui(new Ui::InitFrequencyPlanningDialog),
m_dateOfCreation(session->partitionTime()), m_session(session)
{
DEBUG_LOG(m_logger) << "---InitFrequencyPlanningDialog() ";
m_ui->setupUi(this);
DEBUG_LOG(m_logger) << "---InitFrequencyPlanningDialog() ";
m_ui->setupUi(this);
QMap<int32_t, FrequencySet> frequencySets = avmDtc->frequencySets();
QMap<int32_t, FrequencySet> frequencySets = avmDtc->frequencySets();
for (auto it = frequencySets.constBegin(); it != frequencySets.constEnd(); ++it)
m_ui->cbFrequencySets->addItem(QString::fromStdString(it.value().name()), QVariant::fromValue(it.key()));
for (auto it = frequencySets.constBegin(); it != frequencySets.constEnd(); ++it)
m_ui->cbFrequencySets->addItem(QString::fromStdString(it.value().name()), QVariant::fromValue(it.key()));
m_ui->tbTime->setText(DTG::toStringMSec(m_dateOfCreation));
connect(m_ui->tbTime, &QToolButton::clicked, this, [this]()
{
m_dateOfCreation = m_session->partitionTime();
m_ui->tbTime->setText(DTG::toStringMSec(m_dateOfCreation));
});
m_uiRequirements->addRequirement( { m_ui->lblName, [this]() { return !m_ui->leName->text().isEmpty(); } });
m_uiRequirements->addRequirement( { m_ui->lblFrequencySets, [this]() { return !m_ui->cbFrequencySets->currentText().isEmpty(); } });
connect(m_ui->tbTime, &QToolButton::clicked, this, [this]() {
m_dateOfCreation = m_session->partitionTime();
m_ui->tbTime->setText(DTG::toStringMSec(m_dateOfCreation));
});
setOnlineHelpFilename(QStringLiteral("Situation-Frequency_Planning"));
m_uiRequirements->addRequirement({m_ui->lblName, [this]() { return !m_ui->leName->text().isEmpty(); }});
m_uiRequirements->addRequirement(
{m_ui->lblFrequencySets, [this]() { return !m_ui->cbFrequencySets->currentText().isEmpty(); }});
setOnlineHelpFilename(QStringLiteral("Situation-Frequency_Planning"));
}
InitFrequencyPlanningDialog::~InitFrequencyPlanningDialog()
{
delete m_ui;
delete m_ui;
}
void InitFrequencyPlanningDialog::retranslate()
{
translate(m_ui, tr("New Frequency Planning"));
translate(m_ui, tr("New Frequency Planning"));
}
bool InitFrequencyPlanningDialog::apply()
{
FrequencyPlanning planning;
FrequencyPlanning planning;
planning.id(0);
if(m_session->exerciseId() != 0)
planning.exerciseId(m_session->exerciseId());
planning.frequencySetId(m_ui->cbFrequencySets->currentData().toInt());
planning.name(m_ui->leName->text().toStdString());
planning.date(m_dateOfCreation);
planning.id(0);
if (m_session->exerciseId() != 0)
planning.exerciseId(m_session->exerciseId());
planning.frequencySetId(m_ui->cbFrequencySets->currentData().toInt());
planning.name(m_ui->leName->text().toStdString());
planning.date(m_dateOfCreation);
emit newInitFrequencyPlanning(planning);
emit newInitFrequencyPlanning(planning);
return true;
return true;
}
}
} // namespace AudioVideoManagement
@@ -1,12 +1,10 @@
#pragma once
#include <LtsWidgets/lts_dialog.h>
#include <AudioVideoManagement/logger.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/logger.h>
#include <LtsWidgets/lts_dialog.h>
class QCheckBox;
@@ -24,23 +22,23 @@ namespace AudioVideoManagement
{
class InitFrequencyPlanningDialog : public LtsWidgets::LtsDialog
{
Q_OBJECT
public:
explicit InitFrequencyPlanningDialog(LtsSession::LtsSession *session, const std::shared_ptr<Interface::Dtc> &avmDtc, QWidget *parent);
Q_OBJECT
public:
explicit InitFrequencyPlanningDialog(LtsSession::LtsSession* session, const std::shared_ptr<Interface::Dtc>& avmDtc,
QWidget* parent);
~InitFrequencyPlanningDialog();
~InitFrequencyPlanningDialog();
signals:
void newInitFrequencyPlanning(const FrequencyPlanning &);
signals:
void newInitFrequencyPlanning(const FrequencyPlanning&);
private:
private:
NGL::INGLLogger& m_logger;
void retranslate() override;
bool apply() override;
NGL::INGLLogger &m_logger;
void retranslate() override;
bool apply() override;
Ui::InitFrequencyPlanningDialog *m_ui;
qint64 m_dateOfCreation;
LtsSession::LtsSession *m_session;
};
}
Ui::InitFrequencyPlanningDialog* m_ui;
qint64 m_dateOfCreation;
LtsSession::LtsSession* m_session;
};
} // namespace AudioVideoManagement
@@ -1,11 +1,10 @@
#pragma once
#include <LtsWidgets/lts_frameless_dialog.h>
#include <AudioVideoManagement/avm_dtc.h>
#include <AudioVideoManagement/logger.h>
#include <LtsWidgets/lts_frameless_dialog.h>
namespace Ui
{
@@ -23,7 +22,7 @@ namespace Interface
{
class Dtc;
}
}
} // namespace InfrastructureManagement
namespace ExerciseManagement
{
@@ -31,38 +30,35 @@ namespace Interface
{
class Dtc;
}
}
} // namespace ExerciseManagement
namespace AudioVideoManagement
{
class LoadFrequencyPlanningDialogModel;
class LoadFrequencyPlanningDialog
: public LtsWidgets::LtsFramelessDialog
class LoadFrequencyPlanningDialog : public LtsWidgets::LtsFramelessDialog
{
Q_OBJECT
public:
explicit LoadFrequencyPlanningDialog(const QByteArray &data,
const FrequencyPlanning &initPlan,
const std::shared_ptr<AudioVideoManagement::Interface::Dtc> &avmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc> &ismDtc,
QWidget *parent = nullptr);
Q_OBJECT
public:
explicit LoadFrequencyPlanningDialog(const QByteArray& data, const FrequencyPlanning& initPlan,
const std::shared_ptr<AudioVideoManagement::Interface::Dtc>& avmDtc,
const std::shared_ptr<InfrastructureManagement::Interface::Dtc>& ismDtc,
QWidget* parent = nullptr);
~LoadFrequencyPlanningDialog();
~LoadFrequencyPlanningDialog();
QVector<int32_t> unassignments() const;
QVector<FrequencyPlanningData> newPlanningData() const;
QVector<int32_t> unassignments() const;
QVector<FrequencyPlanningData> newPlanningData() const;
bool isApplied() const;
bool isApplied() const;
private Q_SLOTS:
void onOk();
private Q_SLOTS:
void onOk();
private:
NGL::INGLLogger &m_logger;
std::unique_ptr<Ui::LoadFrequencyPlanningDialog> m_ui;
LoadFrequencyPlanningDialogModel *m_model;
bool m_isApplied = false;
};
}
private:
NGL::INGLLogger& m_logger;
std::unique_ptr<Ui::LoadFrequencyPlanningDialog> m_ui;
LoadFrequencyPlanningDialogModel* m_model;
bool m_isApplied = false;
};
} // namespace AudioVideoManagement