Complete Qt6 migration: full clean build green across groups G1-G12 incl. runtime plugin set

new_docker_build.sh gains Group 12 (212 GUI/Data plugins); fixes LtsUtilsGuiDds visibility (LTO-stripped exports), LtsProjectionWorkstation unity name shadow, 6 unity-off dirs (dup file-scope statics, ddsftc INTERFACE sources) and reconfigures BUILD_FILTERMANAGEMENT/BUILD_PLUGINS_SERVICEMONITOR=ON

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_cnr_json_helper.cpp

@@ -22,8 +22,8 @@ QByteArray cnrConfigVectorToJson(const QVector<CnrConfig> &configVector, int32_t
 
   for (const CnrConfig &config : std::as_const(configVector))
   {
-    if((isGlobal && config.exerciseId().is_set())
-       || (!isGlobal && !config.exerciseId().is_set()))
+    if((isGlobal && config.exerciseId.has_value())
+       || (!isGlobal && !config.exerciseId.has_value()))
      continue;
 
     arr += cnrConfigToJson(config);
@@ -43,12 +43,12 @@ QJsonObject cnrConfigToJson(const CnrConfig &config)
 
   using namespace JsonKeys;
 
-  cnrObj.insert(CALL_SIGN(), QString::fromStdString(config.callSign()));
-  cnrObj.insert(CNR_CHANNEL_ID(), config.cnrChannelId());
-  cnrObj.insert(IS_GLOBAL(), !config.exerciseId().is_set());
-  cnrObj.insert(RADIO_CIRCUIT(), QString::fromStdString(config.radioCircuit()));
-  cnrObj.insert(IS_ACTIVE(), config.isActive());
-  cnrObj.insert(RECORDING(), config.recording());
+  cnrObj.insert(CALL_SIGN(), QString::fromStdString(config.callSign));
+  cnrObj.insert(CNR_CHANNEL_ID(), config.cnrChannelId);
+  cnrObj.insert(IS_GLOBAL(), !config.exerciseId.has_value());
+  cnrObj.insert(RADIO_CIRCUIT(), QString::fromStdString(config.radioCircuit));
+  cnrObj.insert(IS_ACTIVE(), config.isActive);
+  cnrObj.insert(RECORDING(), config.recording);
 
   return cnrObj;
 }
@@ -60,12 +60,12 @@ T jsonToCnr(const QJsonObject &cnrJson)
 
   using namespace JsonKeys ;
 
-  cnrConfigRequest.callSign(cnrJson.value(CALL_SIGN()).toString().toStdString());
-  cnrConfigRequest.cnrChannelId(cnrJson.value(CNR_CHANNEL_ID()).toInt());
-  cnrConfigRequest.id(0);
-  cnrConfigRequest.radioCircuit(cnrJson.value(RADIO_CIRCUIT()).toString().toStdString());
+  cnrConfigRequest.callSign = cnrJson.value(CALL_SIGN()).toString().toStdString();
+  cnrConfigRequest.cnrChannelId = cnrJson.value(CNR_CHANNEL_ID()).toInt();
+  cnrConfigRequest.id = 0;
+  cnrConfigRequest.radioCircuit = cnrJson.value(RADIO_CIRCUIT()).toString().toStdString();
 
-  cnrConfigRequest.recording(cnrJson.value(RECORDING()).toBool());
+  cnrConfigRequest.recording = cnrJson.value(RECORDING()).toBool();
 
   return cnrConfigRequest;
 }

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_combat_net_radio_dialog.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_combat_net_radio_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "avm_cnr_json_helper.h"
 #include "avm_combat_net_radio_dialog_model.h"
@@ -20,6 +21,7 @@ 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))
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     m_ui->setupUi(this);
     setUnchangeable(true);
@@ -128,7 +130,7 @@ void CombatNetRadioDialog::onEditClicked()
     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()),
+    addDialog(dialog, m_menuGroup, QStringLiteral("EditCNRConfig%1").arg(config.id),
               LtsWidgets::LayoutArea::eDialogTab);
 }
 
@@ -139,7 +141,7 @@ void CombatNetRadioDialog::onRemoveClicked()
     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); });
 }
@@ -157,7 +159,7 @@ void CombatNetRadioDialog::onSelectionChanged()
 
     CnrConfig config = m_model->data(currentIndex, Qt::UserRole).value<CnrConfig>();
     bool enabled =
-        rowSelected && (config.exerciseId().is_set() || m_session->partitionType() == IDL::PartitionType::Global);
+        rowSelected && (config.exerciseId.has_value() || m_session->partitionType() == IDL::PartitionType::Global);
     m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, enabled);
     m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, enabled);
 }

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_combat_net_radio_dialog_model.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_combat_net_radio_dialog_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "avm_cnr_json_helper.h"
 
@@ -19,6 +20,7 @@ CombatNetRadioDialogModel::CombatNetRadioDialogModel(int32_t exerciseId, QObject
     : LtsAbstractTableModel<CnrConfig>(
           {tr("Channel Number"), tr("Radio Circuit"), tr("Code Word"), tr("Party"), tr("Unit"), tr("Global")}, parent),
       m_exerciseId(exerciseId)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
 }
 
@@ -34,43 +36,43 @@ QVariant CombatNetRadioDialogModel::data(const QModelIndex& index, int role) con
         {
             case CHANNEL:
                 INFO_LOG(m_logger) << "CombatNetRadioDialogModel::data role =" << role << " row = " << index.row();
-                return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId()).name());
+                return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId).name);
             case RADIO_CIRCUIT:
-                return QString::fromStdString(config.radioCircuit());
+                return QString::fromStdString(config.radioCircuit);
             case CALL_SIGN:
-                return QString::fromStdString(config.callSign());
+                return QString::fromStdString(config.callSign);
             case PARTY:
-                if (config.exerciseId().is_set() || config.partyId() > 0)
-                    return ParticipantManagement::trPartyName(m_parties.value(config.partyId()).name());
+                if (config.exerciseId.has_value() || config.partyId > 0)
+                    return ParticipantManagement::trPartyName(m_parties.value(config.partyId).name);
                 else
                     return QStringLiteral("-");
             case UNIT: {
-                if (!config.unitId().is_set())
+                if (!config.unitId.has_value())
                     return {};
-                const int unitId = config.unitId().get();
-                const auto unit = m_units.value(config.unitId().get());
-                if (unit.id() != unitId)
+                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();
+                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()));
+                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");
+                return config.exerciseId.has_value() ? tr("No") : tr("Yes");
         }
     }
     else if (role == Qt::BackgroundRole)
     {
-        if (config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId)
+        if (config.exerciseId.has_value() && config.exerciseId.get() == m_exerciseId)
             return {};
-        if (!config.exerciseId().is_set() && m_exerciseId <= 0)
+        if (!config.exerciseId.has_value() && m_exerciseId <= 0)
             return {};
         return QColor(Qt::gray);
     }
@@ -105,7 +107,7 @@ bool CombatNetRadioDialogModel::onlyGlobals()
 {
     for (const CnrConfig& config : std::as_const(m_vecData))
     {
-        if (config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId)
+        if (config.exerciseId.has_value() && config.exerciseId.get() == m_exerciseId)
             return false;
     }
     return true;
@@ -136,7 +138,7 @@ bool CombatNetRadioDialogFilter::filterAcceptsRow(int sourceRow, const QModelInd
 {
     CnrConfig cnrConfig = m_sourceModel->getRowData(sourceRow);
 
-    if (cnrConfig.exerciseId().is_set() && cnrConfig.exerciseId().get() != m_exerciseId)
+    if (cnrConfig.exerciseId.has_value() && cnrConfig.exerciseId.get() != m_exerciseId)
         return false;
 
     return LtsColumnFilterProxyModel::filterAcceptsRow(sourceRow, sourceParent);

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_combat_net_radio_dialog_model.h

@@ -7,6 +7,7 @@
 #include <LtsWidgets/lts_abstract_table_model.h>
 #include <LtsWidgets/lts_column_filter_proxy_model.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
 #include <cstdint>
 #include <memory>

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_edit_combat_net_radio_dialog.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_edit_combat_net_radio_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "ui_avm_edit_combat_net_radio_dialog.h"
 
@@ -25,9 +26,9 @@ namespace
 
 CnrConfig toConfig(const ModifyCnrConfigRequest& modifyRequest)
 {
-    return {modifyRequest.id(),           modifyRequest.cnrChannelId(), modifyRequest.exerciseId(),
-            modifyRequest.radioCircuit(), modifyRequest.partyId(),      modifyRequest.unitId(),
-            modifyRequest.recording(),    modifyRequest.callSign(),     false};
+    return {modifyRequest.id,           modifyRequest.cnrChannelId, modifyRequest.exerciseId,
+            modifyRequest.radioCircuit, modifyRequest.partyId,      modifyRequest.unitId,
+            modifyRequest.recording,    modifyRequest.callSign,     false};
 }
 
 const QString& NO_CHANNEL()
@@ -61,9 +62,9 @@ EditCombatNetRadioDialog::EditCombatNetRadioDialog(const CnrConfig& cnrConfig, i
                                                    const std::shared_ptr<Interface::Dtc>& avmDtc,
                                                    const std::shared_ptr<Interface::Ftc>& avmFtc,
                                                    ExerciseManagement::Interface::Dtc* exmDtc, QWidget* parent)
-    : EditCombatNetRadioDialog(cnrConfig.id(), exerciseId, session, ppmDtc, avmDtc, avmFtc, exmDtc, parent)
+    : EditCombatNetRadioDialog(cnrConfig.id, exerciseId, session, ppmDtc, avmDtc, avmFtc, exmDtc, parent)
 {
-    m_channelId = cnrConfig.cnrChannelId();
+    m_channelId = cnrConfig.cnrChannelId;
     m_isGlobal = session->partitionType() == IDL::PartitionType::Global;
     setUiValues(cnrConfig);
 
@@ -79,6 +80,7 @@ EditCombatNetRadioDialog::EditCombatNetRadioDialog(const boost::optional<int32_t
     : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel),
       m_ui(new Ui::EditCombatNetRadioDialog), m_id(id), m_exerciseId(exerciseId), m_ppmDtc(ppmDtc), m_avmDtc(avmDtc),
       m_avmFtc(avmFtc), m_exmDtc(exmDtc), m_requestHelper(new LtsUtils::RequestHelper(this))
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     Q_ASSERT(ppmDtc);
     Q_ASSERT(avmDtc);
@@ -109,19 +111,19 @@ void EditCombatNetRadioDialog::setUiValues(const CnrConfig& cnrConfig)
         setUiValuesForGlobal();
 
     m_ui->chkGlobal->setChecked(m_isGlobal);
-    initCbChannels(cnrConfig.cnrChannelId());
+    initCbChannels(cnrConfig.cnrChannelId);
     bool disableParty =
-        (m_avmDtc->cnrChannel(cnrConfig.cnrChannelId()).frequencyBand() == FrequencyBand::REL) || m_isGlobal;
+        (m_avmDtc->cnrChannel(cnrConfig.cnrChannelId).frequencyBand == FrequencyBand::REL) || m_isGlobal;
     if (!disableParty)
     {
-        m_ui->cbParty->setCurrentIndex(m_ui->cbParty->findData(cnrConfig.partyId()));
-        int unitId = cnrConfig.unitId().is_set() ? cnrConfig.unitId().get() : 0;
+        m_ui->cbParty->setCurrentIndex(m_ui->cbParty->findData(cnrConfig.partyId));
+        int unitId = cnrConfig.unitId.has_value() ? cnrConfig.unitId.get() : 0;
         m_ui->cbUnit->setCurrentIndex(m_ui->cbUnit->findData(unitId));
     }
-    m_ui->leCallSign->setText(QString::fromStdString(cnrConfig.callSign()));
-    m_ui->chkRecording->setChecked(cnrConfig.recording());
-    m_ui->leRadioCircuit->setText(QString::fromStdString(cnrConfig.radioCircuit()));
-    onPartyIndexChanged(cnrConfig.partyId());
+    m_ui->leCallSign->setText(QString::fromStdString(cnrConfig.callSign));
+    m_ui->chkRecording->setChecked(cnrConfig.recording);
+    m_ui->leRadioCircuit->setText(QString::fromStdString(cnrConfig.radioCircuit));
+    onPartyIndexChanged(cnrConfig.partyId);
 }
 
 void EditCombatNetRadioDialog::setUiValuesForGlobal()
@@ -139,16 +141,16 @@ ModifyCnrConfigRequest EditCombatNetRadioDialog::createRequest()
 {
     ModifyCnrConfigRequest request;
 
-    request.id(m_id.get_value_or(0));
-    request.callSign(m_ui->leCallSign->text().toStdString());
-    request.cnrChannelId(m_ui->cbChannel->currentData().toInt());
-    request.radioCircuit(m_ui->leRadioCircuit->text().toStdString());
-    request.recording(m_ui->chkRecording->isChecked());
-    request.partyId(m_ui->cbParty->currentData().toInt());
+    request.id = m_id.get_value_or(0);
+    request.callSign = m_ui->leCallSign->text().toStdString();
+    request.cnrChannelId = m_ui->cbChannel->currentData().toInt();
+    request.radioCircuit = m_ui->leRadioCircuit->text().toStdString();
+    request.recording = m_ui->chkRecording->isChecked();
+    request.partyId = m_ui->cbParty->currentData().toInt();
     if (!m_isGlobal)
-        request.exerciseId(m_exerciseId);
+        request.exerciseId = m_exerciseId;
     if (m_ui->cbUnit->currentIndex() > 0)
-        request.unitId().set(m_ui->cbUnit->currentIndex());
+        request.unitId.set(m_ui->cbUnit->currentIndex());
     return request;
 }
 
@@ -158,8 +160,8 @@ bool EditCombatNetRadioDialog::apply()
 
     if (m_ui->cbUnit->currentIndex() > 0)
     {
-        request.unitId().set(m_ui->cbUnit->currentData().toInt());
-        INFO_LOG(m_logger) << "currentIndex=" << m_ui->cbUnit->currentIndex() << " unitId =" << request.unitId().get();
+        request.unitId.set(m_ui->cbUnit->currentData().toInt());
+        INFO_LOG(m_logger) << "currentIndex=" << m_ui->cbUnit->currentIndex() << " unitId =" << request.unitId.get();
     }
 
     return m_requestHelper->startSingleRequest(
@@ -176,7 +178,7 @@ void EditCombatNetRadioDialog::init(LtsSession::LtsSession* session)
         ERROR_LOG(m_logger) << "Could not retrieve visible Parties!";
 
     for (const ParticipantManagement::Party& party : std::as_const(parties))
-        m_ui->cbParty->addItem(ParticipantManagement::trPartyName(party.name()), party.id());
+        m_ui->cbParty->addItem(ParticipantManagement::trPartyName(party.name), party.id);
 
     connect(m_ui->cbParty, QOverload<int>::of(&LtsWidgets::LtsComboBox::currentIndexChanged), this,
             &EditCombatNetRadioDialog::onPartyIndexChanged);
@@ -231,44 +233,44 @@ void EditCombatNetRadioDialog::updateFreeChannelsAndTakenNames()
     QMap<int, QString> exerciseNameCache;
     const auto allCnrConfigs = m_avmDtc->cnrConfigs();
     const ExerciseManagement::Exercise ownExercise = m_exmDtc->exercise(m_exerciseId);
-    ExerciseManagement::ExerciseState ownState = m_exmDtc->exercise(m_exerciseId).state();
+    ExerciseManagement::ExerciseState ownState = m_exmDtc->exercise(m_exerciseId).state;
 
     for (const AudioVideoManagement::CnrConfig& cnrConfig : allCnrConfigs)
     {
-        if (m_id.is_initialized() && *m_id == cnrConfig.id())
+        if (m_id.is_initialized() && *m_id == cnrConfig.id)
             continue;
 
-        if (ownExercise.state() == ExerciseManagement::ExerciseState::Created && cnrConfig.exerciseId() != m_exerciseId)
+        if (ownExercise.state == ExerciseManagement::ExerciseState::Created && cnrConfig.exerciseId != m_exerciseId)
         {
-            if (ownExercise.linkedExerciseId() < 1 || cnrConfig.exerciseId() != ownExercise.linkedExerciseId())
+            if (ownExercise.linkedExerciseId < 1 || cnrConfig.exerciseId != ownExercise.linkedExerciseId)
                 continue;
 
-            if (!exerciseNameCache.contains(ownExercise.linkedExerciseId()))
+            if (!exerciseNameCache.contains(ownExercise.linkedExerciseId))
                 exerciseNameCache.insert(
-                    ownExercise.linkedExerciseId(),
-                    QString::fromStdString(m_exmDtc->exercise(ownExercise.linkedExerciseId()).name()));
+                    ownExercise.linkedExerciseId,
+                    QString::fromStdString(m_exmDtc->exercise(ownExercise.linkedExerciseId).name));
 
             channelsToDisable.insert(
-                cnrConfig.cnrChannelId(),
-                tr("(already taken in %1)").arg(exerciseNameCache.value(ownExercise.linkedExerciseId())));
+                cnrConfig.cnrChannelId,
+                tr("(already taken in %1)").arg(exerciseNameCache.value(ownExercise.linkedExerciseId)));
 
             continue;
         }
 
-        if (ownExercise.state() == ExerciseManagement::ExerciseState::Started ||
-            ownExercise.state() == ExerciseManagement::ExerciseState::Paused)
+        if (ownExercise.state == ExerciseManagement::ExerciseState::Started ||
+            ownExercise.state == ExerciseManagement::ExerciseState::Paused)
         {
-            if (cnrConfig.exerciseId().is_set())
+            if (cnrConfig.exerciseId.has_value())
             {
-                int cnrExerciseId = cnrConfig.exerciseId().get();
+                int cnrExerciseId = cnrConfig.exerciseId.get();
 
                 if (exercisesConsider.contains(cnrExerciseId) && cnrExerciseId != m_exerciseId)
                 {
                     if (!exerciseNameCache.contains(cnrExerciseId))
                         exerciseNameCache.insert(cnrExerciseId,
-                                                 QString::fromStdString(m_exmDtc->exercise(cnrExerciseId).name()));
+                                                 QString::fromStdString(m_exmDtc->exercise(cnrExerciseId).name));
 
-                    channelsToDisable.insert(cnrConfig.cnrChannelId(),
+                    channelsToDisable.insert(cnrConfig.cnrChannelId,
                                              tr("(already taken in %1)").arg(exerciseNameCache.value(cnrExerciseId)));
 
                     continue;
@@ -278,36 +280,36 @@ void EditCombatNetRadioDialog::updateFreeChannelsAndTakenNames()
 
         if (!m_isGlobal)
         {
-            if (cnrConfig.exerciseId().is_set() && !exercisesConsider.contains(cnrConfig.exerciseId().get()))
+            if (cnrConfig.exerciseId.has_value() && !exercisesConsider.contains(cnrConfig.exerciseId.get()))
                 continue;
 
-            if (!cnrConfig.exerciseId().is_set() && ownState != ExerciseManagement::ExerciseState::Created)
+            if (!cnrConfig.exerciseId.has_value() && ownState != ExerciseManagement::ExerciseState::Created)
             {
-                channelsToDisable.insert(cnrConfig.cnrChannelId(), tr("(already taken in global exercise)"));
+                channelsToDisable.insert(cnrConfig.cnrChannelId, tr("(already taken in global exercise)"));
 
                 continue;
             }
         }
 
-        if (m_isGlobal && cnrConfig.exerciseId().is_set() && exercisesConsider.contains(cnrConfig.exerciseId().get()))
+        if (m_isGlobal && cnrConfig.exerciseId.has_value() && exercisesConsider.contains(cnrConfig.exerciseId.get()))
         {
-            int exerciseId = cnrConfig.exerciseId().get();
+            int exerciseId = cnrConfig.exerciseId.get();
 
             if (!exerciseNameCache.contains(exerciseId))
-                exerciseNameCache.insert(exerciseId, QString::fromStdString(m_exmDtc->exercise(exerciseId).name()));
+                exerciseNameCache.insert(exerciseId, QString::fromStdString(m_exmDtc->exercise(exerciseId).name));
 
-            channelsToDisable.insert(cnrConfig.cnrChannelId(),
+            channelsToDisable.insert(cnrConfig.cnrChannelId,
                                      tr("(already taken in %1)").arg(exerciseNameCache.value(exerciseId)));
 
             continue;
         }
 
-        if (cnrConfig.exerciseId().is_set() && exercisesIgnore.contains(cnrConfig.exerciseId().get()))
+        if (cnrConfig.exerciseId.has_value() && exercisesIgnore.contains(cnrConfig.exerciseId.get()))
             continue;
 
-        m_takenNames.push_back(QString::fromStdString(cnrConfig.radioCircuit()));
+        m_takenNames.push_back(QString::fromStdString(cnrConfig.radioCircuit));
 
-        freeChannels.removeOne(cnrConfig.cnrChannelId());
+        freeChannels.removeOne(cnrConfig.cnrChannelId);
     }
 
     if (m_id.is_initialized())
@@ -326,8 +328,8 @@ void EditCombatNetRadioDialog::updateCbChannels(QVector<int>&& freeChannels, QMa
     const auto allChannels = m_avmDtc->cnrChannels();
 
     const auto byName = [&allChannels](int leftChannelId, int rightChannelId) {
-        return QLatin1String(allChannels[leftChannelId].name().c_str()) <
-               QLatin1String(allChannels[rightChannelId].name().c_str());
+        return QLatin1String(allChannels[leftChannelId].name.c_str()) <
+               QLatin1String(allChannels[rightChannelId].name.c_str());
     };
     std::sort(freeChannels.begin(), freeChannels.end(), byName);
 
@@ -360,7 +362,7 @@ void EditCombatNetRadioDialog::updateCbChannels(QVector<int>&& freeChannels, QMa
     m_ui->cbChannel->clear();
     for (const auto& channelId : freeChannels)
     {
-        QString channelName = QString::fromStdString(allChannels[channelId].name());
+        QString channelName = QString::fromStdString(allChannels[channelId].name);
 
         if (channelsToDisable.contains(channelId))
         {
@@ -407,23 +409,23 @@ QVector<int> EditCombatNetRadioDialog::exercisesToConsider() const
     QVector<int> toBeConsidered;
     toBeConsidered.reserve(allExercises.size());
 
-    if (!m_isGlobal && currentExercise.state() == ExerciseManagement::ExerciseState::Created)
+    if (!m_isGlobal && currentExercise.state == ExerciseManagement::ExerciseState::Created)
     {
-        toBeConsidered.append(currentExercise.id());
+        toBeConsidered.append(currentExercise.id);
 
-        if (currentExercise.linkedExerciseId() > 0)
-            toBeConsidered.append(currentExercise.linkedExerciseId());
+        if (currentExercise.linkedExerciseId > 0)
+            toBeConsidered.append(currentExercise.linkedExerciseId);
 
         return toBeConsidered;
     }
 
-    if (!m_isGlobal && !isActive(allExercises[m_exerciseId].state()))
+    if (!m_isGlobal && !isActive(allExercises[m_exerciseId].state))
         return {m_exerciseId};
 
     for (const auto& exercise : allExercises)
     {
-        if (isActive(exercise.state()))
-            toBeConsidered.append(exercise.id());
+        if (isActive(exercise.state))
+            toBeConsidered.append(exercise.id);
     }
 
     return toBeConsidered;
@@ -436,19 +438,19 @@ QVector<int> EditCombatNetRadioDialog::exercisesToIgnore() const
     auto canBeIgnored = [this](const ExerciseManagement::Exercise& ex) -> bool {
         if (m_isGlobal)
         {
-            return (ex.state() == ExerciseManagement::ExerciseState::Created ||
-                    ex.state() == ExerciseManagement::ExerciseState::Stopped ||
-                    ex.state() == ExerciseManagement::ExerciseState::Terminated || ex.isDeleted());
+            return (ex.state == ExerciseManagement::ExerciseState::Created ||
+                    ex.state == ExerciseManagement::ExerciseState::Stopped ||
+                    ex.state == ExerciseManagement::ExerciseState::Terminated || ex.isDeleted);
         }
-        return (ex.state() == ExerciseManagement::ExerciseState::Stopped ||
-                ex.state() == ExerciseManagement::ExerciseState::Terminated || ex.isDeleted());
+        return (ex.state == ExerciseManagement::ExerciseState::Stopped ||
+                ex.state == ExerciseManagement::ExerciseState::Terminated || ex.isDeleted);
     };
 
     QVector<int> exercisesToIgnore;
     for (const auto& ex : allExercises)
     {
         if (canBeIgnored(ex))
-            exercisesToIgnore += ex.id();
+            exercisesToIgnore += ex.id;
     }
     return exercisesToIgnore;
 }
@@ -473,17 +475,17 @@ void EditCombatNetRadioDialog::onPartyIndexChanged(int index)
     for (const ParticipantManagement::Participant& unit : std::as_const(m_units))
     {
         QString unitStr;
-        if (unit.partyId() == partyId)
+        if (unit.partyId == partyId)
         {
-            if (unit.designator().size() > 0)
+            if (unit.designator.size() > 0)
             {
-                unitStr = QString::fromStdString(unit.designator()) + QLatin1Char('/');
+                unitStr = QString::fromStdString(unit.designator) + QLatin1Char('/');
                 INFO_LOG(m_logger) << "Designator != leer: unitStr = " << unitStr;
             }
-            unitStr += QString::fromStdString(unit.tacticalIdentifier());
-            INFO_LOG(m_logger) << "unitStr =" << unitStr << " id =" << unit.id();
+            unitStr += QString::fromStdString(unit.tacticalIdentifier);
+            INFO_LOG(m_logger) << "unitStr =" << unitStr << " id =" << unit.id;
 
-            m_ui->cbUnit->addItem(unitStr, unit.id());
+            m_ui->cbUnit->addItem(unitStr, unit.id);
         }
     }
 }
@@ -492,7 +494,7 @@ void EditCombatNetRadioDialog::onChannelChanged(int index)
 {
     int channelId = m_ui->cbChannel->itemData(index).toInt();
 
-    bool disableParty = (m_avmDtc->cnrChannel(channelId).frequencyBand() == FrequencyBand::REL) || m_isGlobal;
+    bool disableParty = (m_avmDtc->cnrChannel(channelId).frequencyBand == FrequencyBand::REL) || m_isGlobal;
     m_ui->cbUnit->setDisabled(disableParty);
     m_ui->lbUnit->setDisabled(disableParty);
     m_ui->cbParty->setDisabled(disableParty);
@@ -509,16 +511,16 @@ QByteArray EditCombatNetRadioDialog::cnrConfigRequestToJson()
     ModifyCnrConfigRequest req = createRequest();
 
     QJsonObject obj;
-    obj[QStringLiteral("id")] = req.id();
+    obj[QStringLiteral("id")] = req.id;
     obj[QStringLiteral("XmlType")] = FileManagement::toString(FileManagement::XmlType::AVMEditCombatNetRadio);
-    obj[QStringLiteral("callSign")] = QString::fromStdString(req.callSign());
-    obj[QStringLiteral("cnrChannelId")] = req.cnrChannelId();
-    obj[QStringLiteral("radioCircuit")] = QString::fromStdString(req.radioCircuit());
-    obj[QStringLiteral("recording")] = req.recording();
-    obj[QStringLiteral("partyId")] = req.partyId();
-    obj[QStringLiteral("isGlobal")] = !req.exerciseId().is_set();
-    if (req.unitId().is_set())
-        obj[QStringLiteral("unitId")] = req.unitId().get();
+    obj[QStringLiteral("callSign")] = QString::fromStdString(req.callSign);
+    obj[QStringLiteral("cnrChannelId")] = req.cnrChannelId;
+    obj[QStringLiteral("radioCircuit")] = QString::fromStdString(req.radioCircuit);
+    obj[QStringLiteral("recording")] = req.recording;
+    obj[QStringLiteral("partyId")] = req.partyId;
+    obj[QStringLiteral("isGlobal")] = !req.exerciseId.has_value();
+    if (req.unitId.has_value())
+        obj[QStringLiteral("unitId")] = req.unitId.get();
     QJsonDocument doc(obj);
     return doc.toJson(QJsonDocument::Compact);
 }
@@ -529,16 +531,16 @@ ModifyCnrConfigRequest EditCombatNetRadioDialog::jsonToModifyCnrConfig(const QBy
     const QJsonDocument doc(QJsonDocument::fromJson(content));
     const QJsonObject obj(doc.object());
 
-    result.id(obj[QStringLiteral("id")].toInt());
-    result.callSign(obj[QStringLiteral("callSign")].toString().toStdString());
-    result.cnrChannelId(obj[QStringLiteral("cnrChannelId")].toInt());
-    result.radioCircuit(obj[QStringLiteral("radioCircuit")].toString().toStdString());
-    result.recording(obj[QStringLiteral("recording")].toInt());
-    result.partyId(obj[QStringLiteral("partyId")].toInt());
+    result.id = obj[QStringLiteral("id")].toInt();
+    result.callSign = obj[QStringLiteral("callSign")].toString().toStdString();
+    result.cnrChannelId = obj[QStringLiteral("cnrChannelId")].toInt();
+    result.radioCircuit = obj[QStringLiteral("radioCircuit")].toString().toStdString();
+    result.recording = obj[QStringLiteral("recording")].toInt();
+    result.partyId = obj[QStringLiteral("partyId")].toInt();
     if (!obj.contains(QLatin1String("isGlobal")) || !obj[QLatin1String("isGlobal")].toBool())
-        result.exerciseId(m_exerciseId);
+        result.exerciseId = m_exerciseId;
     if (obj.contains(QStringLiteral("unitId")))
-        result.unitId(obj[QStringLiteral("unitId")].toInt());
+        result.unitId = obj[QStringLiteral("unitId")].toInt();
 
     return result;
 }

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_edit_combat_net_radio_dialog.h

@@ -9,6 +9,7 @@
 #include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
 #include <LtsWidgets/lts_dialog.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <FileManagement/flm_explorer_gui_plugin_interface.h>
 #include <QtCore/QString>
 #include <QtCore/QVector>

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_load_combat_net_radio_dialog.cpp

@@ -2,6 +2,7 @@
 
 
 #include "avm_load_combat_net_radio_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 #include "ui_avm_load_combat_net_radio_dialog.h"
 
 #include "avm_cnr_json_helper.h"
@@ -15,6 +16,7 @@ LoadCombatNetRadioDialog::LoadCombatNetRadioDialog(const QByteArray &data,
   : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
   , m_ui(new Ui::LoadCombatNetRadioDialog)
   , m_model(new LoadCombatNetRadioDialogModel(data, session))
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
   m_ui->setupUi(this);
   m_ui->dataView->setModel(m_model);

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/CombatNetRadioConfiguration/avm_load_combat_net_radio_dialog_model.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_load_combat_net_radio_dialog_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "avm_cnr_json_helper.h"
 
@@ -24,6 +25,7 @@ LoadCombatNetRadioDialogModel::LoadCombatNetRadioDialogModel(const QByteArray& d
     : LtsAbstractTableModel<CnrConfig>(
           {tr("Include"), tr("Channel"), tr("Radio Circuit"), tr("Code Word"), tr("Conflict(s)")}, parent),
       m_exerciseId(session == nullptr ? 0 : session->exerciseId())
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     DEBUG_LOG(m_logger) << "Own exercise id: " << m_exerciseId;
 
@@ -109,11 +111,11 @@ QVariant LoadCombatNetRadioDialogModel::data(const QModelIndex& index, int role)
             switch (index.column())
             {
                 case CHANNEL:
-                    return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId()).name());
+                    return QString::fromStdString(m_cnrChannels.value(config.cnrChannelId).name);
                 case RADIO_CIRCUIT:
-                    return QString::fromStdString(config.radioCircuit());
+                    return QString::fromStdString(config.radioCircuit);
                 case CALL_SIGN:
-                    return QString::fromStdString(config.callSign());
+                    return QString::fromStdString(config.callSign);
                 case CONFLICTS:
                     return conflictsText(m_conflicts.at(index.row()));
                 default:
@@ -169,44 +171,44 @@ LoadCombatNetRadioDialogModel::Conflicts LoadCombatNetRadioDialogModel::getConfl
         if (!(conflicts & RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG) && isRadioCircuitTakenInOwnConfig(config, it.value()))
         {
             conflicts |= RADIO_CIRCUIT_TAKEN_IN_OWN_CONFIG;
-            addConflictedCnr(row, it.value().id());
+            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());
+            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());
+            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());
+            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());
+            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());
+            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());
+            addConflictedCnr(row, it.value().id);
         }
     }
 
@@ -253,7 +255,7 @@ bool LoadCombatNetRadioDialogModel::isActiveExercise(int32_t exerciseId) const
 
     using namespace ExerciseManagement;
 
-    ExerciseState exerciseState = m_exercises.value(exerciseId).state();
+    ExerciseState exerciseState = m_exercises.value(exerciseId).state;
 
     return exerciseState == ExerciseState::Started || exerciseState == ExerciseState::Paused;
 }
@@ -273,10 +275,10 @@ bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInOwnConfig(const CnrConf
                                                                    const CnrConfig& existingConfig) const
 {
     if (m_exerciseId == 0)
-        return !existingConfig.exerciseId().is_set() && existingConfig.radioCircuit() == loadConfig.radioCircuit();
+        return !existingConfig.exerciseId.has_value() && existingConfig.radioCircuit == loadConfig.radioCircuit;
 
-    if (!existingConfig.exerciseId().is_set() || existingConfig.exerciseId().get() != m_exerciseId ||
-        existingConfig.radioCircuit() != loadConfig.radioCircuit())
+    if (!existingConfig.exerciseId.has_value() || existingConfig.exerciseId.get() != m_exerciseId ||
+        existingConfig.radioCircuit != loadConfig.radioCircuit)
         return false;
 
     return true;
@@ -285,9 +287,9 @@ bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInOwnConfig(const CnrConf
 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())
+    if (!isActiveExercise(m_exerciseId) || !existingConfig.exerciseId.has_value() ||
+        !isActiveExercise(existingConfig.exerciseId.get()) || existingConfig.exerciseId.get() == m_exerciseId ||
+        existingConfig.radioCircuit != loadConfig.radioCircuit)
         return false;
 
     return true;
@@ -296,10 +298,10 @@ bool LoadCombatNetRadioDialogModel::isRadioCircuitTakenInAnotherExercise(const C
 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.has_value() ? existingConfig.exerciseId.get() : 0;
 
     if (!isActiveExercise(m_exerciseId) || exerciseId == 0 || exerciseId == m_exerciseId ||
-        !isActiveExercise(exerciseId) || existingConfig.cnrChannelId() != loadConfig.cnrChannelId() ||
+        !isActiveExercise(exerciseId) || existingConfig.cnrChannelId != loadConfig.cnrChannelId ||
         !isActiveExercise(exerciseId))
         return false;
 
@@ -309,14 +311,14 @@ bool LoadCombatNetRadioDialogModel::isChannelTakenInActiveExercise(const CnrConf
 bool LoadCombatNetRadioDialogModel::isChannelTakenInLinkedExercise(const CnrConfig& loadConfig,
                                                                    const CnrConfig& existingConfig) const
 {
-    if (m_exerciseId == 0 || m_exercises.value(m_exerciseId).linkedExerciseId() == 0)
+    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.has_value() ? existingConfig.exerciseId.get() : 0;
 
-    if (exerciseId != linkedExerciseId || existingConfig.cnrChannelId() != loadConfig.cnrChannelId())
+    if (exerciseId != linkedExerciseId || existingConfig.cnrChannelId != loadConfig.cnrChannelId)
         return false;
 
     return true;
@@ -325,16 +327,16 @@ bool LoadCombatNetRadioDialogModel::isChannelTakenInLinkedExercise(const CnrConf
 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.has_value() ? 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
 {
-    if (!isActiveExercise(m_exerciseId) || m_exerciseId == 0 || existingConfig.exerciseId().is_set() ||
-        existingConfig.cnrChannelId() != loadConfig.cnrChannelId())
+    if (!isActiveExercise(m_exerciseId) || m_exerciseId == 0 || existingConfig.exerciseId.has_value() ||
+        existingConfig.cnrChannelId != loadConfig.cnrChannelId)
         return false;
 
     return true;
@@ -343,8 +345,8 @@ bool LoadCombatNetRadioDialogModel::isChannelTakenInGlobal(const CnrConfig& load
 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())
+    if (!isActiveExercise(m_exerciseId) || m_exerciseId == 0 || existingConfig.exerciseId.has_value() ||
+        existingConfig.radioCircuit != loadConfig.radioCircuit)
         return false;
 
     return true;
@@ -397,13 +399,13 @@ QVector<ModifyCnrConfigRequest> LoadCombatNetRadioDialogModel::modifyRequests()
         const CnrConfig& cnrConfig = m_vecData.at(row);
 
         modifyRequestsVec.append({0,
-                                  cnrConfig.cnrChannelId(),
+                                  cnrConfig.cnrChannelId,
                                   exerciseId,
-                                  cnrConfig.radioCircuit(),
-                                  cnrConfig.recording(),
+                                  cnrConfig.radioCircuit,
+                                  cnrConfig.recording,
                                   {},
                                   partyId,
-                                  cnrConfig.callSign()});
+                                  cnrConfig.callSign});
     }
 
     return modifyRequestsVec;

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_dialog.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_edit_frequency_planning_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "avm_edit_frequency_planning_frequency_data_model.h"
 #include "avm_load_frequency_planning_dialog.h"
@@ -16,6 +17,7 @@
 #include <LtsSession/lts_session_data.h>
 #include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <ParticipantManagement/ppm_translation.h>
 #include <PluginInterfaces/gui_plugin_interface.h>
 #include <QtWidgets/QTreeView>
@@ -47,13 +49,14 @@ EditFrequencyPlanningDialog::EditFrequencyPlanningDialog(
       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_frequencyPlanningId(copy ? 0 : planning.id), m_exerciseId(session->exerciseId()),
       m_isEdit(EditFrequencyPlanningSetResourceDialog::DialogMode::Assign), m_activeFrequencyPlanningStatus(0)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     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(); }});
 
@@ -138,11 +141,11 @@ bool EditFrequencyPlanningDialog::apply()
     }
     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); });
@@ -157,18 +160,18 @@ void EditFrequencyPlanningDialog::onAddClicked()
         return;
 
     CnrConfig cnrConfigRow = m_frequencyDataModel->itemData(idx).cnrConfig;
-    int cnrConfigId = cnrConfigRow.id();
+    int cnrConfigId = cnrConfigRow.id;
     if (cnrConfigId <= 0)
         return;
 
     DEBUG_LOG(m_logger) << "---RessourceDialog aufrufen...."
-                        << " cnrConfigId: " << cnrConfigId << " radioCircuit: " << cnrConfigRow.radioCircuit()
+                        << " cnrConfigId: " << cnrConfigId << " radioCircuit: " << cnrConfigRow.radioCircuit
                         << " FrequencySetId: " << m_frequencyDataModel->getFrequencySetId();
 
     FrequencyPlanningData fpd = m_frequencyDataModel->getfrequencyPlanningData(cnrConfigId);
-    if (!fpd.cnrConfigId())
+    if (!fpd.cnrConfigId)
     {
-        fpd.cnrConfigId(cnrConfigId);
+        fpd.cnrConfigId = cnrConfigId;
     }
 
     EditFrequencyPlanningResourceDialog* frequencyPlanningResourceDialog =
@@ -194,7 +197,7 @@ void EditFrequencyPlanningDialog::onRemoveClicked()
         return;
 
     CnrConfig cnrConfigRow = m_frequencyDataModel->itemData(idx).cnrConfig;
-    int cnrConfigId = cnrConfigRow.id();
+    int cnrConfigId = cnrConfigRow.id;
     if (cnrConfigId <= 0)
         return;
     unassignRadioCircuit(cnrConfigId);
@@ -209,17 +212,17 @@ void EditFrequencyPlanningDialog::enableSelectedUnassignButton()
 
     auto itemData = m_frequencyDataModel->itemData(idx);
     CnrConfig cnrConfigRow = itemData.cnrConfig;
-    int cnrConfigId = cnrConfigRow.id();
+    int cnrConfigId = cnrConfigRow.id;
     if (cnrConfigId <= 0)
         return;
 
     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);
 
-    if ((!cnrConfigRow.exerciseId().is_set() && m_planning.exerciseId().is_set()) || itemData.readOnly)
+    if ((!cnrConfigRow.exerciseId.has_value() && m_planning.exerciseId.has_value()) || itemData.readOnly)
     {
         m_buttonBox->setText(LtsWidgets::DialogButton::Add, tr("Show"));
         m_isEdit = EditFrequencyPlanningSetResourceDialog::DialogMode::Show;
@@ -238,7 +241,7 @@ void EditFrequencyPlanningDialog::enableSelectedUnassignButton()
     }
 
     DEBUG_LOG(m_logger) << "---enableAssignUnassignButtons()...."
-                        << " cnrConfigId: " << cnrConfigId << " radioCircuitId: " << cnrConfigRow.radioCircuit();
+                        << " cnrConfigId: " << cnrConfigId << " radioCircuitId: " << cnrConfigRow.radioCircuit;
 
     m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove,
                                   !itemData.readOnly &&
@@ -250,7 +253,7 @@ void EditFrequencyPlanningDialog::enableSelectedUnassignButton()
 void EditFrequencyPlanningDialog::onAssignRadioCircuit(const FrequencyPlanningData& fpd)
 {
     DEBUG_LOG(m_logger) << "---onAssignRadioCircuit()...."
-                        << "CnrConfigId: " << fpd.cnrConfigId();
+                        << "CnrConfigId: " << fpd.cnrConfigId;
 
     m_frequencyDataModel->setFrequencyPlanningData(fpd);
 
@@ -288,21 +291,21 @@ QVector<int> EditFrequencyPlanningDialog::otherActiveExercises() const
 {
     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(); });
+                                 [](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)
+        if (exercise.id == m_exerciseId)
             continue;
 
-        if (::isActive(exercise.state()))
-            toBeConsidered.append(exercise.id());
+        if (::isActive(exercise.state))
+            toBeConsidered.append(exercise.id);
     }
     return toBeConsidered;
 }
@@ -315,8 +318,8 @@ QVector<int> EditFrequencyPlanningDialog::otherActivePlans() const
     const auto activePlans = m_avmDtc->activeFrequencyPlannings();
     for (const auto& activePlan : activePlans)
     {
-        if (exercises.contains(activePlan.exerciseId()))
-            result.append(activePlan.frequencyPlanningId());
+        if (exercises.contains(activePlan.exerciseId))
+            result.append(activePlan.frequencyPlanningId);
     }
     return result;
 }

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_dialog.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <AudioVideoManagement/avm_qmetatypes.h>
 #include <LtsWidgets/lts_dialog.h>
 
 #include <AudioVideoManagement/logger.h>

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_frequency_data_model.cpp

@@ -1,12 +1,14 @@
 
 
 #include "avm_edit_frequency_planning_frequency_data_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include <AudioVideoManagement/avm_translation.h>
 #include <FileManagement/flm_translation.h>
 #include <InfrastructureManagement/ism_dtc.h>
 #include <LtsUtilsCore/json_object.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <ParticipantManagement/ppm_translation.h>
 #include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
 #include <QtCore/QJsonArray>
@@ -23,7 +25,7 @@ void EditFrequencyPlanningFrequencyDataModel::onFrequencyPlanningChanged(const F
                                                                          DataModification dm)
 {
 
-    if (planning.id() != m_initPlan.id() && planning.exerciseId().is_set())
+    if (planning.id != m_initPlan.id && planning.exerciseId.has_value())
         return;
 
     if (dm == DataModification::eRemoved)
@@ -44,24 +46,24 @@ void EditFrequencyPlanningFrequencyDataModel::onFrequencyPlanningChanged(const F
         return;
     }
     QHash<int, FrequencyPlanningData> fpdMap;
-    for (const auto& elem : planning.data())
-        fpdMap.insert(elem.cnrConfigId(), elem);
+    for (const auto& elem : planning.data)
+        fpdMap.insert(elem.cnrConfigId, elem);
     for (NGLTreeItem* item : m_rootItem->constChildren())
     {
         if (!item->data().canConvert<ItemData>())
             continue;
 
         ItemData itemData = item->data().value<ItemData>();
-        if (itemData.cnrConfig.exerciseId().is_set() && itemData.cnrConfig.exerciseId().get() != m_exerciseId)
+        if (itemData.cnrConfig.exerciseId.has_value() && itemData.cnrConfig.exerciseId.get() != m_exerciseId)
             continue;
 
-        if (!itemData.cnrConfig.exerciseId().is_set() && 0 != m_exerciseId)
+        if (!itemData.cnrConfig.exerciseId.has_value() && 0 != m_exerciseId)
             continue;
 
-        if (fpdMap.contains(itemData.cnrConfig.id()))
+        if (fpdMap.contains(itemData.cnrConfig.id))
         {
 
-            const FrequencyPlanningData& fpd = fpdMap[itemData.cnrConfig.id()];
+            const FrequencyPlanningData& fpd = fpdMap[itemData.cnrConfig.id];
 
             if (item->childCount())
             {
@@ -73,7 +75,7 @@ void EditFrequencyPlanningFrequencyDataModel::onFrequencyPlanningChanged(const F
             delete itemData.radioCircuit;
             itemData.radioCircuit = nullptr;
 
-            QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
+            QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties);
             if (circuits.size() > 1)
             {
                 for (RadioCircuit* circuit : std::as_const(circuits))
@@ -88,8 +90,8 @@ void EditFrequencyPlanningFrequencyDataModel::onFrequencyPlanningChanged(const F
                 itemData.radioCircuit = circuits[0];
                 item->setData(QVariant::fromValue(itemData));
             }
-            m_frequencyPlanningData[fpd.cnrConfigId()] = fpd;
-            fpdMap.remove(itemData.cnrConfig.id());
+            m_frequencyPlanningData[fpd.cnrConfigId] = fpd;
+            fpdMap.remove(itemData.cnrConfig.id);
         }
         else
         {
@@ -103,7 +105,7 @@ void EditFrequencyPlanningFrequencyDataModel::onFrequencyPlanningChanged(const F
             delete itemData.radioCircuit;
             itemData.radioCircuit = nullptr;
             item->setData(QVariant::fromValue(itemData));
-            m_frequencyPlanningData.remove(itemData.cnrConfig.id());
+            m_frequencyPlanningData.remove(itemData.cnrConfig.id);
         }
     }
 
@@ -140,15 +142,16 @@ EditFrequencyPlanningFrequencyDataModel::EditFrequencyPlanningFrequencyDataModel
                        tr("Global"),
                    }),
       m_exerciseId(exerciseId), m_avmDtc(avmDtc), m_ismDtc(ismDtc), m_ppmDtc(ppmDtc), m_initPlan(initPlanning)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     Q_ASSERT(avmDtc);
     Q_ASSERT(ppmDtc);
     DEBUG_LOG(m_logger) << "---EditFrequencyPlanningDataMod m_frequencyPlanningData[c.id()];el() ";
 
-    int frequencySetId = initPlanning.frequencySetId();
-    std::vector<FrequencySetDataWithId> fsdVec = m_avmDtc->frequencySet(frequencySetId).data();
+    int frequencySetId = initPlanning.frequencySetId;
+    std::vector<FrequencySetDataWithId> fsdVec = m_avmDtc->frequencySet(frequencySetId).data;
     for (FrequencySetDataWithId fsd : fsdVec)
-        m_freqSetData.insert(fsd.id(), fsd);
+        m_freqSetData.insert(fsd.id, fsd);
 
     m_units = m_ppmDtc->units();
 
@@ -157,15 +160,15 @@ EditFrequencyPlanningFrequencyDataModel::EditFrequencyPlanningFrequencyDataModel
     for (const CnrConfig& cnrConfig : cnrConfigs)
     {
 
-        if (cnrConfig.exerciseId().is_set() && cnrConfig.exerciseId().get() != m_exerciseId)
+        if (cnrConfig.exerciseId.has_value() && cnrConfig.exerciseId.get() != m_exerciseId)
             continue;
         dataVec.append(cnrConfig);
     }
     setCnrConfigs(dataVec);
     m_avmDtc->activeFrequencyPlannings([this](const ActiveFrequencyPlanning& afp) {
-        if (afp.exerciseId() <= 0)
+        if (afp.exerciseId <= 0)
         {
-            onFrequencyPlanningChanged(m_avmDtc->frequencyPlanning(afp.frequencyPlanningId()),
+            onFrequencyPlanningChanged(m_avmDtc->frequencyPlanning(afp.frequencyPlanningId),
                                        DataModification::eAdded);
         }
     });
@@ -182,13 +185,13 @@ void EditFrequencyPlanningFrequencyDataModel::setCnrConfigs(const QVector<CnrCon
     m_cnrConfigs.clear();
     for (const CnrConfig& c : dataVec)
     {
-        m_cnrConfigs.insert(c.id(), c);
+        m_cnrConfigs.insert(c.id, c);
         ItemData id(c);
-        if (m_frequencyPlanningData.contains(c.id()))
+        if (m_frequencyPlanningData.contains(c.id))
         {
-            FrequencyPlanningData fpd = m_frequencyPlanningData[c.id()];
-            id.readOnly = isReadOnly(fpd.properties());
-            QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
+            FrequencyPlanningData fpd = m_frequencyPlanningData[c.id];
+            id.readOnly = isReadOnly(fpd.properties);
+            QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties);
             if (circuits.size() > 1)
             {
                 ConfigTreeItem* configItem = new ConfigTreeItem(QVariant::fromValue(id));
@@ -227,7 +230,7 @@ EditFrequencyPlanningFrequencyDataModel::itemData(const QModelIndex& index)
 
 QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index, int role) const
 {
-    if ((role != Qt::DisplayRole && role != Qt::ToolTipRole && role != Qt::UserRole && role != Qt::TextColorRole &&
+    if ((role != Qt::DisplayRole && role != Qt::ToolTipRole && role != Qt::UserRole && role != Qt::ForegroundRole &&
          role != Qt::BackgroundRole) ||
         !index.isValid())
         return NGLTreeModel::data(index, role);
@@ -265,11 +268,11 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
         {
 
             case RADIO_CIRCUIT_ID:
-                return setData.id();
+                return setData.id;
             case FUNCTION: {
                 if (!rc)
                     return QStringLiteral("-");
-                return QString::fromStdString(m_freqSetData[rc->frequencySetDataId()].function());
+                return QString::fromStdString(m_freqSetData[rc->frequencySetDataId()].function);
             }
             case DEVICE: {
 
@@ -278,7 +281,7 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
                 RadioCircuitVHF* rcVhf = dynamic_cast<RadioCircuitVHF*>(rc);
                 if (!rcVhf)
                     return QStringLiteral("-");
-                return toString(m_freqSetData[rc->frequencySetDataId()].frequencyBand().underlying());
+                return toString(m_freqSetData[rc->frequencySetDataId()].frequencyBand);
             }
             case FREQUENCY: {
                 QLocale locale(QLocale::German);
@@ -290,7 +293,7 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
                     if (rcVhf && isAkwMode(rcVhf->operatingMode))
                         return QStringLiteral("-");
                     return tr("%1 MHz").arg(
-                        locale.toString(m_freqSetData[rc->frequencySetDataId()].frequency() / 1000., 'f', 3));
+                        locale.toString(m_freqSetData[rc->frequencySetDataId()].frequency / 1000., 'f', 3));
                 }
                 else
                 {
@@ -310,67 +313,67 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].akwBundle().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].akwBundle.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].akwBundle().get();
+                return m_freqSetData[rc->frequencySetDataId()].akwBundle.get();
             }
             case FSB_BUNDLE: {
                 if (!rc)
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].fsbBundle().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].fsbBundle.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].fsbBundle().get();
+                return m_freqSetData[rc->frequencySetDataId()].fsbBundle.get();
             }
             case AKW_RADIO_CIRCUIT: {
                 if (!rc)
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit().get();
+                return m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit.get();
             }
             case COMSEC: {
                 if (!rc)
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].comsec().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].comsec.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].comsec().get();
+                return m_freqSetData[rc->frequencySetDataId()].comsec.get();
             }
 
             case RADIO_CIRCUIT: {
                 if (!rc)
-                    return QString::fromStdString(setData.radioCircuit());
+                    return QString::fromStdString(setData.radioCircuit);
 
                 return id.name();
             }
             case PARTY: {
-                ParticipantManagement::Party party = m_ppmDtc->party(setData.partyId());
+                ParticipantManagement::Party party = m_ppmDtc->party(setData.partyId);
 
-                return ParticipantManagement::trPartyName(party.name());
+                return ParticipantManagement::trPartyName(party.name);
             }
             case UNIT: {
-                if (!setData.unitId().is_set())
+                if (!setData.unitId.has_value())
                     return {};
-                const int unitId = setData.unitId().get();
+                const int unitId = setData.unitId.get();
                 if (!m_units.contains(unitId))
                     return QStringLiteral("-");
                 const auto unit = m_units[unitId];
 
-                INFO_LOG(m_logger) << " config.unitId()=" << unitId << " Str=" << unit.name();
+                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()));
+                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;
@@ -382,7 +385,7 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
                 if (rc->radioStationId == 0)
                     return tr("Automatic");
                 else
-                    return QString::fromStdString(m_ismDtc->mainStructureElement(rc->radioStationId).name());
+                    return QString::fromStdString(m_ismDtc->mainStructureElement(rc->radioStationId).name);
             }
             case PILOTTON: {
                 if (!rc)
@@ -405,11 +408,11 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
                 return toString(rcVhf->operatingMode);
             }
             case CHANNEL: {
-                CnrChannel channel = m_avmDtc->cnrChannel(setData.cnrChannelId());
-                return QString::fromStdString(channel.name());
+                CnrChannel channel = m_avmDtc->cnrChannel(setData.cnrChannelId);
+                return QString::fromStdString(channel.name);
             }
             case GLOBAL: {
-                return setData.exerciseId().is_set() ? tr("No") : tr("Yes");
+                return setData.exerciseId.has_value() ? tr("No") : tr("Yes");
             }
             case PROPERTIES: {
                 if (!rc)
@@ -463,22 +466,22 @@ QVariant EditFrequencyPlanningFrequencyDataModel::data(const QModelIndex& index,
     }
 
     if (role == Qt::UserRole)
-        return setData.id();
+        return setData.id;
 
-    if (role == Qt::TextColorRole)
+    if (role == Qt::ForegroundRole)
     {
 
         for (int id : m_multipleAssignedCnrIds)
         {
-            if (id == setData.id())
+            if (id == setData.id)
                 return QColor(Qt::red);
         }
     }
     if (role == Qt::BackgroundRole)
     {
-        if (setData.exerciseId().is_set() && setData.exerciseId().get() == m_exerciseId)
+        if (setData.exerciseId.has_value() && setData.exerciseId.get() == m_exerciseId)
             return NGLTreeModel::data(index, role);
-        if (!setData.exerciseId().is_set() && m_exerciseId <= 0)
+        if (!setData.exerciseId.has_value() && m_exerciseId <= 0)
             return NGLTreeModel::data(index, role);
         return QColor(Qt::gray);
     }
@@ -546,15 +549,15 @@ bool EditFrequencyPlanningFrequencyDataModel::unassignRadioCircuit(int32_t cnrCo
 
 void EditFrequencyPlanningFrequencyDataModel::setFrequencePlanningId(int id)
 {
-    if (m_initPlan.id() == id)
+    if (m_initPlan.id == id)
         return;
-    if (m_initPlan.id() <= 0)
+    if (m_initPlan.id <= 0)
     {
-        m_initPlan.id(id);
+        m_initPlan.id = id;
         return;
     }
     WARNING_LOG(m_logger) << "Trying to set a new frequency planning id but there is alreay an id set ("
-                          << m_initPlan.id() << " - " << id << ")";
+                          << m_initPlan.id << " - " << id << ")";
 }
 
 ModifyFrequencyPlanningRequest EditFrequencyPlanningFrequencyDataModel::modifyFrequencyPlanningRequest() const
@@ -565,21 +568,21 @@ ModifyFrequencyPlanningRequest EditFrequencyPlanningFrequencyDataModel::modifyFr
     for (const auto& keyValue : overKeyValue(m_frequencyPlanningData))
     {
         Q_ASSERT(keyValue.first > 0);
-        CnrConfig config = m_avmDtc->cnrConfig(keyValue.second.cnrConfigId());
-        if ((config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId) ||
-            (!config.exerciseId().is_set() && m_exerciseId == 0))
+        CnrConfig config = m_avmDtc->cnrConfig(keyValue.second.cnrConfigId);
+        if ((config.exerciseId.has_value() && config.exerciseId.get() == m_exerciseId) ||
+            (!config.exerciseId.has_value() && m_exerciseId == 0))
         {
             FrequencyPlanningData fpd = keyValue.second;
-            fpd.frequencyPlanningId() = m_initPlan.id();
+            fpd.frequencyPlanningId = m_initPlan.id;
             planningDataVec.push_back(fpd);
         }
     }
 
-    return {m_initPlan.id(),
-            m_initPlan.exerciseId().is_set() ? m_initPlan.exerciseId().get() : 0,
-            m_initPlan.name(),
-            m_initPlan.date(),
-            m_initPlan.frequencySetId(),
+    return {m_initPlan.id,
+            m_initPlan.exerciseId.has_value() ? m_initPlan.exerciseId.get() : 0,
+            m_initPlan.name,
+            m_initPlan.date,
+            m_initPlan.frequencySetId,
             planningDataVec};
 }
 
@@ -591,18 +594,18 @@ FrequencyPlanning EditFrequencyPlanningFrequencyDataModel::toFrequencyPlanning()
     for (const auto& keyValue : overKeyValue(m_frequencyPlanningData))
     {
         Q_ASSERT(keyValue.first > 0);
-        CnrConfig config = m_avmDtc->cnrConfig(keyValue.second.cnrConfigId());
-        if ((config.exerciseId().is_set() && config.exerciseId().get() == m_exerciseId) ||
-            (!config.exerciseId().is_set() && m_exerciseId == 0))
+        CnrConfig config = m_avmDtc->cnrConfig(keyValue.second.cnrConfigId);
+        if ((config.exerciseId.has_value() && config.exerciseId.get() == m_exerciseId) ||
+            (!config.exerciseId.has_value() && m_exerciseId == 0))
         {
             FrequencyPlanningData fpd = keyValue.second;
-            fpd.frequencyPlanningId() = m_initPlan.id();
+            fpd.frequencyPlanningId = m_initPlan.id;
             planningDataVec.push_back(fpd);
         }
     }
 
     FrequencyPlanning frequencyPlanning = m_initPlan;
-    frequencyPlanning.data(planningDataVec);
+    frequencyPlanning.data = planningDataVec;
 
     return frequencyPlanning;
 }
@@ -611,12 +614,12 @@ int EditFrequencyPlanningFrequencyDataModel::findCnrConfigByName(const QString&
 {
     int id = -1;
     std::function<bool(const CnrConfig&)> findByNameInExercise = [this, &name, &id](const CnrConfig& cnrConfig) {
-        if (cnrConfig.exerciseId().is_set() && cnrConfig.exerciseId() != m_initPlan.exerciseId())
+        if (cnrConfig.exerciseId.has_value() && cnrConfig.exerciseId != m_initPlan.exerciseId)
             return false;
-        if (QString::fromStdString(cnrConfig.radioCircuit()) != name)
+        if (QString::fromStdString(cnrConfig.radioCircuit) != name)
             return false;
 
-        id = cnrConfig.id();
+        id = cnrConfig.id;
         return true;
     };
 
@@ -628,7 +631,7 @@ QByteArray EditFrequencyPlanningFrequencyDataModel::uiToJson() const
 {
     QJsonObject obj;
     obj[QStringLiteral("XmlType")] = FileManagement::toString(FileManagement::XmlType::AVMEditFrequencyPlanning);
-    obj[QStringLiteral("frequencySetId")] = m_initPlan.frequencySetId();
+    obj[QStringLiteral("frequencySetId")] = m_initPlan.frequencySetId;
 
     QJsonArray arr;
     for (const auto& keyValue : overKeyValue(m_frequencyPlanningData))
@@ -636,8 +639,8 @@ QByteArray EditFrequencyPlanningFrequencyDataModel::uiToJson() const
         QJsonObject inner;
         const FrequencyPlanningData& info = keyValue.second;
 
-        inner[QStringLiteral("cnrChannelId")] = m_avmDtc->cnrConfig(info.cnrConfigId()).cnrChannelId();
-        inner[QStringLiteral("properties")] = QString::fromStdString(info.properties());
+        inner[QStringLiteral("cnrChannelId")] = m_avmDtc->cnrConfig(info.cnrConfigId).cnrChannelId;
+        inner[QStringLiteral("properties")] = QString::fromStdString(info.properties);
 
         arr.append(inner);
     }
@@ -651,15 +654,15 @@ QByteArray EditFrequencyPlanningFrequencyDataModel::uiToJson() const
 
 void EditFrequencyPlanningFrequencyDataModel::setFrequencyPlanningData(const FrequencyPlanningData& fpd)
 {
-    ConfigTreeItem* item = searchCnrConfig(m_rootItem, fpd.cnrConfigId());
+    ConfigTreeItem* item = searchCnrConfig(m_rootItem, fpd.cnrConfigId);
     if (!item)
     {
-        if (!m_cnrConfigs.contains(fpd.cnrConfigId()))
+        if (!m_cnrConfigs.contains(fpd.cnrConfigId))
             return;
         beginResetModel();
-        ItemData data(m_cnrConfigs[fpd.cnrConfigId()]);
-        data.readOnly = isReadOnly(fpd.properties());
-        QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
+        ItemData data(m_cnrConfigs[fpd.cnrConfigId]);
+        data.readOnly = isReadOnly(fpd.properties);
+        QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties);
         if (circuits.size() > 1)
         {
             ConfigTreeItem* configItem = new ConfigTreeItem(QVariant::fromValue(data));
@@ -677,12 +680,12 @@ void EditFrequencyPlanningFrequencyDataModel::setFrequencyPlanningData(const Fre
             ConfigTreeItem* configItem = new ConfigTreeItem(QVariant::fromValue(data));
             insertRow(m_rootItem->childCount(), indexFromItem(m_rootItem), configItem);
         }
-        m_frequencyPlanningData[fpd.cnrConfigId()] = fpd;
+        m_frequencyPlanningData[fpd.cnrConfigId] = fpd;
         endResetModel();
         return;
     }
 
-    QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
+    QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties);
     ItemData data = item->data().value<ItemData>();
     item->removeAllChildren();
 
@@ -690,7 +693,7 @@ void EditFrequencyPlanningFrequencyDataModel::setFrequencyPlanningData(const Fre
     {
         data.radioCircuit = circuits[0];
         item->setData(QVariant::fromValue(data));
-        m_frequencyPlanningData.insert(fpd.cnrConfigId(), fpd);
+        m_frequencyPlanningData.insert(fpd.cnrConfigId, fpd);
     }
     if (circuits.size() <= 1)
         return;
@@ -701,7 +704,7 @@ void EditFrequencyPlanningFrequencyDataModel::setFrequencyPlanningData(const Fre
         ConfigTreeItem* childItem = new ConfigTreeItem(QVariant::fromValue(data));
         insertRow(item->childCount(), indexFromItem(item), childItem);
     }
-    m_frequencyPlanningData.insert(fpd.cnrConfigId(), fpd);
+    m_frequencyPlanningData.insert(fpd.cnrConfigId, fpd);
     endResetModel();
 }
 
@@ -714,12 +717,12 @@ bool EditFrequencyPlanningFrequencyDataModel::checkResourceAssignments()
     {
         const FrequencyPlanningData& p = it.value();
 
-        QSet<int> fsdIdsOuter = frequencySetDataIds(p.properties());
+        QSet<int> fsdIdsOuter = frequencySetDataIds(p.properties);
 
         for (auto startSearchIt = ++it; startSearchIt != m_frequencyPlanningData.constEnd(); ++startSearchIt)
         {
             const FrequencyPlanningData& pI = startSearchIt.value();
-            QSet<int> fsdIdsInner = frequencySetDataIds(pI.properties());
+            QSet<int> fsdIdsInner = frequencySetDataIds(pI.properties);
             for (int inner : std::as_const(fsdIdsInner))
             {
                 for (int outer : std::as_const(fsdIdsOuter))
@@ -727,17 +730,17 @@ bool EditFrequencyPlanningFrequencyDataModel::checkResourceAssignments()
                     if (inner != outer)
                     {
                         DEBUG_LOG(m_logger)
-                            << "---ist ungleich cnrConfigId(A): " << p.cnrConfigId() << " (B): " << pI.cnrConfigId();
+                            << "---ist ungleich cnrConfigId(A): " << p.cnrConfigId << " (B): " << pI.cnrConfigId;
                     }
                     else
                     {
                         DEBUG_LOG(m_logger)
-                            << "---ist gleich cnrConfigId(A): " << p.cnrConfigId() << " (B): " << pI.cnrConfigId();
-                        if (!m_multipleAssignedCnrIds.contains(p.cnrConfigId()))
-                            m_multipleAssignedCnrIds.append(p.cnrConfigId());
+                            << "---ist gleich cnrConfigId(A): " << p.cnrConfigId << " (B): " << pI.cnrConfigId;
+                        if (!m_multipleAssignedCnrIds.contains(p.cnrConfigId))
+                            m_multipleAssignedCnrIds.append(p.cnrConfigId);
 
-                        if (!m_multipleAssignedCnrIds.contains(pI.cnrConfigId()))
-                            m_multipleAssignedCnrIds.append(pI.cnrConfigId());
+                        if (!m_multipleAssignedCnrIds.contains(pI.cnrConfigId))
+                            m_multipleAssignedCnrIds.append(pI.cnrConfigId);
                         bOk = false;
                     }
                 }
@@ -760,31 +763,31 @@ bool EditFrequencyPlanningFrequencyDataModel::checkResourceAssignments()
 bool EditFrequencyPlanningFrequencyDataModel::onCnrConfigChanged(const AudioVideoManagement::CnrConfig& data,
                                                                  DataModification modType)
 {
-    ConfigTreeItem* item = searchCnrConfig(m_rootItem, data.id());
+    ConfigTreeItem* item = searchCnrConfig(m_rootItem, data.id);
 
     if (modType == DataModification::eRemoved)
     {
 
         if (!item)
             return true;
-        m_cnrConfigs.remove(data.id());
-        m_frequencyPlanningData.remove(data.id());
+        m_cnrConfigs.remove(data.id);
+        m_frequencyPlanningData.remove(data.id);
         return removeRow(item->row());
     }
 
     if (modType == DataModification::eAdded ||
-        (!item && data.exerciseId().is_set() && m_exerciseId == data.exerciseId().get()))
+        (!item && data.exerciseId.has_value() && m_exerciseId == data.exerciseId.get()))
     {
         Q_ASSERT(!item);
 
-        m_cnrConfigs.insert(data.id(), data);
+        m_cnrConfigs.insert(data.id, data);
         ConfigTreeItem* newItem = new ConfigTreeItem(QVariant::fromValue(ItemData(data)));
         m_rootItem->setModified(true);
         insertRow(0, indexFromItem(m_rootItem), newItem);
         return true;
     }
 
-    if (item && data.exerciseId().is_set() && m_exerciseId != data.exerciseId().get())
+    if (item && data.exerciseId.has_value() && m_exerciseId != data.exerciseId.get())
         return removeRow(item->row());
 
     if (item)
@@ -794,7 +797,7 @@ bool EditFrequencyPlanningFrequencyDataModel::onCnrConfigChanged(const AudioVide
         item->setData(QVariant::fromValue(id));
 
         if (id.radioCircuit)
-            id.radioCircuit->name = QString::fromStdString(data.radioCircuit());
+            id.radioCircuit->name = QString::fromStdString(data.radioCircuit);
 
         item->setModified(true);
         return true;
@@ -809,7 +812,7 @@ EditFrequencyPlanningFrequencyDataModel::searchCnrConfig(const NGLTreeItem* pare
     for (int r = 0; r < rowCount; ++r)
     {
         ConfigTreeItem* child = static_cast<ConfigTreeItem*>(parentItem->child(r));
-        if (child->data().value<ItemData>().cnrConfig.id() == cnrConfigId)
+        if (child->data().value<ItemData>().cnrConfig.id == cnrConfigId)
             return child;
         child = searchCnrConfig(child, cnrConfigId);
         if (child)
@@ -823,7 +826,7 @@ QSet<int> EditFrequencyPlanningFrequencyDataModel::getAllocatedFrequencyPlanning
     QSet<int> result;
     for (const auto& fpd : std::as_const(m_frequencyPlanningData))
     {
-        result += AudioVideoManagement::frequencySetDataIds(fpd.properties());
+        result += AudioVideoManagement::frequencySetDataIds(fpd.properties);
     }
 
     if (m_exerciseId == 0)
@@ -831,19 +834,19 @@ QSet<int> EditFrequencyPlanningFrequencyDataModel::getAllocatedFrequencyPlanning
         QMap<qint32, AudioVideoManagement::FrequencyPlanning> frequencyPlannings = m_avmDtc->frequencyPlannings();
         for (const auto& frequencyPlanning : std::as_const(frequencyPlannings))
         {
-            if (!frequencyPlanning.exerciseId().is_set())
+            if (!frequencyPlanning.exerciseId.has_value())
                 continue;
 
-            for (const auto& frequencyPlanningData : frequencyPlanning.data())
+            for (const auto& frequencyPlanningData : frequencyPlanning.data)
             {
-                result += AudioVideoManagement::frequencySetDataIds(frequencyPlanningData.properties());
+                result += AudioVideoManagement::frequencySetDataIds(frequencyPlanningData.properties);
             }
         }
     }
     return result;
 }
 
-FPFDelegate::FPFDelegate(QObject* parent) : QStyledItemDelegate(parent), m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
+FPFDelegate::FPFDelegate(QObject* parent) : QStyledItemDelegate(parent)
 {
 }
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_frequency_data_model.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <AudioVideoManagement/avm_qmetatypes.h>
 #include <nglwidgets/ngltreeitem.h>
 #include <AudioVideoManagement/logger.h>
 #include "avm_frequency_planning_helper.h"
@@ -129,7 +130,7 @@ public:
 
   bool unassignRadioCircuit(int32_t cnrConfigId);
 
-  int32_t getFrequencySetId() const { return m_initPlan.frequencySetId(); }
+  int32_t getFrequencySetId() const { return m_initPlan.frequencySetId; }
   QSet<int> getAllocatedFrequencyPlanningSetIds();
 
   ModifyFrequencyPlanningRequest modifyFrequencyPlanningRequest() const;

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_resource_data_model.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_edit_frequency_planning_resource_data_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include <AudioVideoManagement/avm_translation.h>
 #include <Proxies/CombatNetRadio/Helper/cnr_frequency_planning_helper.h>
@@ -23,6 +24,7 @@ EditFrequencyPlanningResourceDataModel::EditFrequencyPlanningResourceDataModel(
           },
           parent),
       m_assignedFrequencySetDataIds(assignedFrequencySetDataIds), m_frequencyBand(frequencyBand)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
 }
 
@@ -38,33 +40,33 @@ QVariant EditFrequencyPlanningResourceDataModel::data(const QModelIndex& index,
         switch (index.column())
         {
             case FREQ_SET_DATA_ID:
-                return setData.id();
+                return setData.id;
             case FUNCTION:
-                return QString::fromStdString(setData.function());
+                return QString::fromStdString(setData.function);
             case DEVICE:
-                return toString(setData.frequencyBand());
+                return toString(setData.frequencyBand);
             case FREQUENCY:
-                return tr("%1 MHz").arg(locale.toString(setData.frequency() / 1000., 'f', 3));
+                return tr("%1 MHz").arg(locale.toString(setData.frequency / 1000., 'f', 3));
             case AKW_BUNDLE:
-                if (setData.akwBundle().is_set())
-                    return setData.akwBundle().get();
+                if (setData.akwBundle.has_value())
+                    return setData.akwBundle.get();
                 return QStringLiteral("-");
             case FSB_BUNDLE:
-                if (setData.fsbBundle().is_set())
-                    return setData.fsbBundle().get();
+                if (setData.fsbBundle.has_value())
+                    return setData.fsbBundle.get();
                 return QStringLiteral("-");
             case AKW_RADIO_CIRCUIT:
-                if (setData.akwRadioCircuit())
-                    return setData.akwRadioCircuit().get();
+                if (setData.akwRadioCircuit)
+                    return setData.akwRadioCircuit.get();
                 return QStringLiteral("-");
             case COMSEC:
-                if (setData.comsec().is_set())
-                    return setData.comsec().get();
+                if (setData.comsec.has_value())
+                    return setData.comsec.get();
                 return QStringLiteral("-");
         }
     }
     else if (role == Qt::UserRole)
-        return setData.id();
+        return setData.id;
 
     return QVariant();
 }
@@ -73,18 +75,18 @@ bool EditFrequencyPlanningResourceDataModel::isFiltered(const AudioVideoManageme
                                                         DataModification modType) const
 {
 
-    if (m_frequencyBand != FrequencyBand::REL && data.frequencyBand() != m_frequencyBand)
+    if (m_frequencyBand != FrequencyBand::REL && data.frequencyBand != m_frequencyBand)
         return true;
 
-    if (m_frequencyBand == FrequencyBand::REL && data.frequencyBand() != FrequencyBand::VHF)
+    if (m_frequencyBand == FrequencyBand::REL && data.frequencyBand != FrequencyBand::VHF)
         return true;
 
     Q_UNUSED(modType);
 
-    if (m_assignedFrequencySetDataIds.contains(data.id()))
+    if (m_assignedFrequencySetDataIds.contains(data.id))
     {
         DEBUG_LOG(m_logger) << "---m_assignments.size(): " << m_assignedFrequencySetDataIds.size()
-                            << " frequencySetDataId: " << data.id() << " ist bereits enthalten";
+                            << " frequencySetDataId: " << data.id << " ist bereits enthalten";
         return true;
     }
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_resource_dialog.cpp

@@ -2,6 +2,7 @@
 
 
 #include "avm_edit_frequency_planning_frequency_data_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 #include <utility>
 #include "avm_edit_frequency_planning_resource_dialog.h"
 #include "ui_avm_edit_frequency_planning_resource_dialog.h"
@@ -10,6 +11,7 @@
 
 #include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <ParticipantManagement/ppm_translation.h>
 #include <AudioVideoManagement/avm_ftc.h>
 #include <AudioVideoManagement/avm_translation.h>
@@ -42,6 +44,7 @@ EditFrequencyPlanningResourceDialog::EditFrequencyPlanningResourceDialog(int fre
   , m_ui(new Ui::EditFrequencyPlanningResourceDialog)
   , m_frequencySetId(frequencySetId)
   , m_dialogMode(dialogMode)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
   m_ui->setupUi(this);
 
@@ -63,18 +66,18 @@ bool EditFrequencyPlanningResourceDialog::init(LtsSession::LtsSession *session,
     return succ;
 
   m_units = m_ppmDtc->units();
-  m_config = m_avmDtc->cnrConfig(m_planningData.cnrConfigId());
+  m_config = m_avmDtc->cnrConfig(m_planningData.cnrConfigId);
 
   
   
 
   
-  m_radioCircuitName = QString::fromStdString(m_config.radioCircuit());
-  CnrChannel channel = m_avmDtc->cnrChannel(m_config.cnrChannelId());
-  m_frequencyBand =   channel.frequencyBand();
+  m_radioCircuitName = QString::fromStdString(m_config.radioCircuit);
+  CnrChannel channel = m_avmDtc->cnrChannel(m_config.cnrChannelId);
+  m_frequencyBand =   channel.frequencyBand;
 
-  QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(planningData.properties());
-  bool readOnly = isReadOnly(planningData.properties());
+  QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(planningData.properties);
+  bool readOnly = isReadOnly(planningData.properties);
   for (RadioCircuit *circuit : std::as_const(circuits))
   {
     addMemberWidget(circuit, readOnly);
@@ -104,7 +107,7 @@ void EditFrequencyPlanningResourceDialog::retranslate()
   
   if (m_dialogMode == EditFrequencyPlanningSetResourceDialog::DialogMode::Edit)
   {
-    translate(m_ui.get(), m_avmDtc->cnrConfig(m_planningData.cnrConfigId()), m_radioCircuitName, tr("Radio Circuit"));
+    translate(m_ui.get(), m_avmDtc->cnrConfig(m_planningData.cnrConfigId), m_radioCircuitName, tr("Radio Circuit"));
   }
   else 
   {
@@ -130,8 +133,8 @@ bool EditFrequencyPlanningResourceDialog::apply()
   doc.setObject(obj);
 
   FrequencyPlanningData fpd;
-  fpd.properties(doc.toJson().toStdString());
-  fpd.cnrConfigId() = m_config.id();
+  fpd.properties = doc.toJson().toStdString();
+  fpd.cnrConfigId = m_config.id;
 
   emit signalAssignRadioCircuit(fpd);
   return true;
@@ -178,10 +181,10 @@ void EditFrequencyPlanningResourceDialog::addMemberWidget(RadioCircuit *radioCir
 void EditFrequencyPlanningResourceDialog::onCnrConfigChanged(const AudioVideoManagement::CnrConfig &config, DataModification modType)
 {
   Q_UNUSED(modType);
-  if (m_config.id() == config.id())
+  if (m_config.id == config.id)
   {
     setLbRadioCiruit(config);
-    m_radioCircuitName = QString::fromStdString(config.radioCircuit());
+    m_radioCircuitName = QString::fromStdString(config.radioCircuit);
     retranslate();
   }
 }
@@ -189,24 +192,24 @@ void EditFrequencyPlanningResourceDialog::onCnrConfigChanged(const AudioVideoMan
 void EditFrequencyPlanningResourceDialog::setLbRadioCiruit(const AudioVideoManagement::CnrConfig &config)
 {
   
-  ParticipantManagement::Party party = m_ppmDtc->party(config.partyId());
-  QString partyName = ParticipantManagement::trPartyName(party.name());
+  ParticipantManagement::Party party = m_ppmDtc->party(config.partyId);
+  QString partyName = ParticipantManagement::trPartyName(party.name);
 
   QString unitString;
-  if (config.unitId().is_set())
+  if (config.unitId.has_value())
   {
-    int unitId = config.unitId().get();
+    int unitId = config.unitId.get();
     auto unit  = m_units.value(unitId);
-    if (unit.id() == unitId)
+    if (unit.id == unitId)
     {
-      if (unit.designator().size() > 0)
-        unitString = QString::fromStdString(unit.designator()) + QLatin1Char('/');
-      unitString.append(QString::fromStdString(unit.tacticalIdentifier()));
+      if (unit.designator.size() > 0)
+        unitString = QString::fromStdString(unit.designator) + QLatin1Char('/');
+      unitString.append(QString::fromStdString(unit.tacticalIdentifier));
     }
   }
   m_ui->lblUnit->setText(unitString);
-  CnrChannel channel = m_avmDtc->cnrChannel(m_config.cnrChannelId());
-  m_ui->lblChannel->setText(QString::fromStdString(channel.name()));
+  CnrChannel channel = m_avmDtc->cnrChannel(m_config.cnrChannelId);
+  m_ui->lblChannel->setText(QString::fromStdString(channel.name));
   m_ui->lblFrequencyBand->setText(toString(m_frequencyBand));
   m_ui->lblRadioCircuit->setText(m_radioCircuitName);
   m_ui->lblParty->setText(partyName);

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_edit_frequency_planning_set_resource_dialog.cpp

@@ -2,6 +2,7 @@
 
 
 #include "avm_edit_frequency_planning_frequency_data_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 #include "avm_edit_frequency_planning_set_resource_dialog.h"
 #include "ui_avm_edit_frequency_planning_set_resource_dialog.h"
 #include "avm_edit_frequency_planning_resource_data_model.h"
@@ -32,26 +33,27 @@ EditFrequencyPlanningSetResourceDialog::EditFrequencyPlanningSetResourceDialog(
   , m_avmDtc(avmDtc)
   , m_frequencyResourceDataModel(nullptr)
   , m_config(m_avmDtc->cnrConfig(cnrConfigId))
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
   m_ui->setupUi(this);
   
-  CnrChannel channel = m_avmDtc->cnrChannel(m_config.cnrChannelId());
+  CnrChannel channel = m_avmDtc->cnrChannel(m_config.cnrChannelId);
 
   
   
-  m_frequencyResourceDataModel = new EditFrequencyPlanningResourceDataModel(assignedFrequencySetDataIds, channel.frequencyBand(), this);
+  m_frequencyResourceDataModel = new EditFrequencyPlanningResourceDataModel(assignedFrequencySetDataIds, channel.frequencyBand, this);
 
-  std::vector<FrequencySetDataWithId> dataVec = m_avmDtc->frequencySet(m_frequencySetId).data();
+  std::vector<FrequencySetDataWithId> dataVec = m_avmDtc->frequencySet(m_frequencySetId).data;
 
   for (const auto &it : dataVec)
   {
     if((operatingMode == RcOperatingMode::AkwEncEccm ||
         operatingMode == RcOperatingMode::AkwEncNone)
-       && it.akwRadioCircuit() == 0) 
+       && it.akwRadioCircuit == 0) 
       continue;
     if((operatingMode != RcOperatingMode::AkwEncEccm &&
         operatingMode != RcOperatingMode::AkwEncNone)
-       && it.akwRadioCircuit() != 0)
+       && it.akwRadioCircuit != 0)
       continue;
     m_frequencyResourceDataModel->insertRow(it);
   }
@@ -81,7 +83,7 @@ void EditFrequencyPlanningSetResourceDialog::accept()
   if (!idx.isValid())
     return;
 
-  emit onSelectedFrequencySet(m_frequencyResourceDataModel->getRowData(idx.row()).id());
+  emit onSelectedFrequencySet(m_frequencyResourceDataModel->getRowData(idx.row()).id);
 }
 
 } 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_frequency_planning_dialog.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_frequency_planning_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "avm_edit_frequency_planning_dialog.h"
 #include "avm_frequency_planning_dialog_model.h"
@@ -15,6 +16,7 @@
 #include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
 #include <LtsWidgets/lts_base_layout_widget.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 #include <PluginInterfaces/gui_plugin_interface.h>
 #include <QtWidgets/QMessageBox>
 #include <QtWidgets/QTreeView>
@@ -28,6 +30,7 @@ FrequencyPlanningDialog::FrequencyPlanningDialog(LtsSession::LtsSession* session
       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_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     m_ui->setupUi(this);
 
@@ -61,9 +64,9 @@ void FrequencyPlanningDialog::unsetActiveFrequencyPlanning()
 void FrequencyPlanningDialog::setActiveFrequencyPlanning(const ActiveFrequencyPlanning& activePlanning)
 {
     m_ui->lbActiveFrequencyPlanning->setText(
-        QString::fromStdString(m_avmDtc->frequencyPlanning(activePlanning.frequencyPlanningId()).name()));
+        QString::fromStdString(m_avmDtc->frequencyPlanning(activePlanning.frequencyPlanningId).name));
     m_activePlanning = activePlanning;
-    m_model->setActivePlanning(m_activePlanning.frequencyPlanningId());
+    m_model->setActivePlanning(m_activePlanning.frequencyPlanningId);
     onSelectionChanged();
 }
 
@@ -128,9 +131,9 @@ bool FrequencyPlanningDialog::init(const std::shared_ptr<Interface::Dtc>& avmDtc
     setStatus(tr("No active Radio Controller connected."), {}, time(0) * 1000, TransmissionReason::TR_Unknown, Qt::red);
     for (auto& elem : m_avmDtc->frequencyPlanningStatuss())
     {
-        if (!elem.isActive())
+        if (!elem.isActive)
             continue;
-        m_activeFrequencyPlanningStatus = elem.id();
+        m_activeFrequencyPlanningStatus = elem.id;
         onFrequencyPlanningStatusChanged(elem, DataModification::eAdded);
     }
     connect(m_avmDtc.get(), &Interface::Dtc::frequencyPlanningStatusChanged, this,
@@ -144,12 +147,12 @@ void FrequencyPlanningDialog::onFrequencyPlanningStatusChanged(
 {
     if (modType == DataModification::eModified)
     {
-        if (data.id() != m_activeFrequencyPlanningStatus)
+        if (data.id != m_activeFrequencyPlanningStatus)
             return;
     }
     else if (modType == DataModification::eRemoved)
     {
-        if (data.id() != m_activeFrequencyPlanningStatus)
+        if (data.id != m_activeFrequencyPlanningStatus)
             return;
 
         m_activeFrequencyPlanningStatus = 0;
@@ -159,28 +162,28 @@ void FrequencyPlanningDialog::onFrequencyPlanningStatusChanged(
     }
     else
     {
-        if (!data.isActive())
+        if (!data.isActive)
             return;
-        m_activeFrequencyPlanningStatus = data.id();
+        m_activeFrequencyPlanningStatus = data.id;
     }
 
-    if (data.activated().is_set())
+    if (data.activated.has_value())
     {
-        setStatus(tr("Activated"), QString::fromStdString(data.requester()), data.activated().get(), data.reason(),
+        setStatus(tr("Activated"), QString::fromStdString(data.requester), data.activated.get(), data.reason,
                   Qt::green);
         return;
     }
 
-    if (data.received().is_set())
+    if (data.received.has_value())
     {
-        setStatus(tr("In Progress"), QString::fromStdString(data.requester()), data.received().get(), data.reason(),
+        setStatus(tr("In Progress"), QString::fromStdString(data.requester), data.received.get(), data.reason,
                   Qt::yellow);
         return;
     }
 
-    if (data.sent().is_set())
+    if (data.sent.has_value())
     {
-        setStatus(tr("Sent"), QString::fromStdString(data.requester()), data.sent().get(),
+        setStatus(tr("Sent"), QString::fromStdString(data.requester), data.sent.get(),
                   TransmissionReason::TR_Unknown, Qt::yellow);
         return;
     }
@@ -255,11 +258,11 @@ void FrequencyPlanningDialog::onAddClicked()
         {
             FrequencyPlanning planning;
 
-            planning.id(0);
+            planning.id = 0;
             if (m_session->exerciseId() != 0)
-                planning.exerciseId(m_session->exerciseId());
-            planning.frequencySetId(frequencySets.first().id());
-            planning.date(m_session->partitionTime());
+                planning.exerciseId = m_session->exerciseId();
+            planning.frequencySetId = frequencySets.first().id;
+            planning.date = m_session->partitionTime();
             showEditDialog(planning);
         }
         else
@@ -278,7 +281,7 @@ void FrequencyPlanningDialog::onAddClicked()
         m_copy = true;
         qint64 dateOfCreation = m_session->partitionTime();
         FrequencyPlanning planning = m_model->data(selectedRows.constFirst(), Qt::UserRole).value<FrequencyPlanning>();
-        planning.date(dateOfCreation);
+        planning.date = dateOfCreation;
         showEditDialog(planning);
     }
 }
@@ -291,8 +294,8 @@ void FrequencyPlanningDialog::onEditClicked()
         return;
 
     const FrequencyPlanning& fp = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>();
-    DEBUG_LOG(m_logger) << "---onEditClicked()  FrequencyPlanningId: " << fp.id()
-                        << " FrequencySetDataId: " << fp.frequencySetId();
+    DEBUG_LOG(m_logger) << "---onEditClicked()  FrequencyPlanningId: " << fp.id
+                        << " FrequencySetDataId: " << fp.frequencySetId;
 
     m_copy = false;
     showEditDialog(m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>());
@@ -305,7 +308,7 @@ void FrequencyPlanningDialog::onRemoveClicked()
     if (!currentIndex.isValid())
         return;
 
-    int planningId = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id();
+    int planningId = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id;
 
     if (m_editDlgMap.contains(planningId))
     {
@@ -315,7 +318,7 @@ void FrequencyPlanningDialog::onRemoveClicked()
 
     Core::RemoveElementRequest req;
 
-    req.id(planningId);
+    req.id = planningId;
 
     m_requestHelper->startSingleRequest([this, req]() { return m_avmFtc->removeFrequencyPlanningRequest(req, this); });
 }
@@ -328,8 +331,8 @@ void FrequencyPlanningDialog::onSelectionChanged()
     if (hasSelection)
     {
         const QModelIndex currentIndex = selectedRows.constFirst();
-        selectedIsActive = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id() ==
-                           m_activePlanning.frequencyPlanningId();
+        selectedIsActive = m_model->data(currentIndex, Qt::UserRole).value<FrequencyPlanning>().id ==
+                           m_activePlanning.frequencyPlanningId;
     }
 
     m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, hasSelection);
@@ -362,9 +365,9 @@ void FrequencyPlanningDialog::onActivateDeactivatePlanningClicked()
     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();
+    bool isActive = planningId == m_activePlanning.frequencyPlanningId;
     if (!isActive)
     {
         ModifyActiveFrequencyPlanningRequest request(m_session->exerciseId(), planningId);
@@ -383,7 +386,7 @@ void FrequencyPlanningDialog::onActivateDeactivatePlanningClicked()
 
 void FrequencyPlanningDialog::showEditDialog(const FrequencyPlanning& planning)
 {
-    QString widgetIdentifier(QStringLiteral("FrequencyPlanning%1").arg(QString::number(planning.id())));
+    QString widgetIdentifier(QStringLiteral("FrequencyPlanning%1").arg(QString::number(planning.id)));
     if (m_copy)
         widgetIdentifier.append(QStringLiteral("Copy"));
 
@@ -402,14 +405,14 @@ void FrequencyPlanningDialog::showEditDialog(const FrequencyPlanning& planning)
 
     if (!m_copy)
     {
-        m_editDlgMap.insert(planning.id(), dlg);
+        m_editDlgMap.insert(planning.id, dlg);
     }
 }
 
 void FrequencyPlanningDialog::onActiveFrequencyPlanningChanged(const ActiveFrequencyPlanning& data,
                                                                DataModification modType)
 {
-    if (data.exerciseId() != m_session->exerciseId())
+    if (data.exerciseId != m_session->exerciseId())
         return;
 
     if (modType == DataModification::eRemoved)

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_frequency_planning_dialog.h

@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include <AudioVideoManagement/avm_qmetatypes.h>
 #include <AudioVideoManagement/avm_ftc.h>
 #include <AudioVideoManagement/logger.h>
 #include <LtsUtils/LtsUtilsCore/data_modification_enum.h>

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_frequency_planning_dialog_model.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_frequency_planning_dialog_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include <FileManagement/flm_translation.h>
 #include <QtCore/QJsonArray>
@@ -14,6 +15,7 @@ namespace AudioVideoManagement
 FrequencyPlanningDialogModel::FrequencyPlanningDialogModel(int32_t exerciseId, QObject* parent)
     : LtsAbstractTableModel<FrequencyPlanning>({tr("Name"), tr("Date"), tr("Set"), tr("Active")}, parent),
       m_exerciseId(exerciseId)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     DEBUG_LOG(m_logger) << "---FrequencyPlanningDialogModel() ";
 }
@@ -29,15 +31,15 @@ QVariant FrequencyPlanningDialogModel::data(const QModelIndex& index, int role)
         switch (index.column())
         {
             case NAME:
-                return QString::fromStdString(planning.name());
+                return QString::fromStdString(planning.name);
             case DATE:
-                return QDateTime::fromMSecsSinceEpoch(planning.date());
+                return QDateTime::fromMSecsSinceEpoch(planning.date);
             case SET: {
-                const FrequencySet frequencySet = m_avmDtc->frequencySet(planning.frequencySetId());
-                return QString::fromStdString(frequencySet.name());
+                const FrequencySet frequencySet = m_avmDtc->frequencySet(planning.frequencySetId);
+                return QString::fromStdString(frequencySet.name);
             }
             case ACTIVE:
-                return planning.id() == m_activePlanningId ? tr("Active") : QStringLiteral("-");
+                return planning.id == m_activePlanningId ? tr("Active") : QStringLiteral("-");
         }
     }
     else if (role == Qt::UserRole)
@@ -56,7 +58,7 @@ bool FrequencyPlanningDialogModel::init(const std::shared_ptr<Interface::Dtc>& a
             &FrequencyPlanningDialogModel::onFrequencyPlanningChanged);
 
     m_avmDtc->frequencyPlannings([this](const FrequencyPlanning& p) {
-        if (p.exerciseId().is_set() && p.exerciseId().get() == m_exerciseId)
+        if (p.exerciseId.has_value() && p.exerciseId.get() == m_exerciseId)
             insertRow(p);
     });
 
@@ -68,15 +70,15 @@ FrequencySet FrequencyPlanningDialogModel::frequencySetByIndex(const QModelIndex
     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)
 {
     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))
+                       << " data.exerciseId()" << data.exerciseId << " m_exerciseId=" << m_exerciseId;
+    if ((data.exerciseId.has_value() && data.exerciseId.get() != m_exerciseId) ||
+        (!data.exerciseId.has_value() && m_exerciseId != 0))
         return;
 
     onDataChanged(data, modType);
@@ -94,21 +96,21 @@ QByteArray FrequencyPlanningDialogModel::modelToJson()
         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("id")] = planning.id;
+        inner[QStringLiteral("name")] = QString::fromStdString(planning.name);
+        inner[QStringLiteral("dateOfCreation")] = static_cast<qint64>(planning.date);
+        if (planning.exerciseId.has_value())
         {
-            inner[QStringLiteral("exerciseId")] = planning.exerciseId().get();
+            inner[QStringLiteral("exerciseId")] = planning.exerciseId.get();
         }
-        inner[QStringLiteral("frequencySetId")] = planning.frequencySetId();
+        inner[QStringLiteral("frequencySetId")] = planning.frequencySetId;
 
         arrData = {};
-        for (const FrequencyPlanningData& planningData : planning.data())
+        for (const FrequencyPlanningData& planningData : planning.data)
         {
             QJsonObject innerData;
-            innerData[QStringLiteral("cnrConfigId")] = planningData.cnrConfigId();
-            innerData[QStringLiteral("properties")] = QString::fromStdString(planningData.properties());
+            innerData[QStringLiteral("cnrConfigId")] = planningData.cnrConfigId;
+            innerData[QStringLiteral("properties")] = QString::fromStdString(planningData.properties);
             arrData += innerData;
         }
         inner[QStringLiteral("data")] = arrData;
@@ -132,21 +134,21 @@ FrequencyPlanningDialogModel::jsonToFrequencyPlanningVector(const QByteArray& co
     {
         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());
+        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());
+        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);
+            frequencyPlanningData.cnrConfigId = objData[QStringLiteral("cnrConfigId")].toInt();
+            frequencyPlanningData.properties = objData[QStringLiteral("properties")].toString().toStdString();
+            frequencyPlanning.data.push_back(frequencyPlanningData);
         }
 
         result.push_back(std::move(frequencyPlanning));
@@ -170,7 +172,7 @@ bool FrequencyPlanningDialogProxyModel::lessThan(const QModelIndex& source_left,
     switch (source_left.column())
     {
         case FrequencyPlanningDialogModel::DATE:
-            return dataLeft.date() < dataRight.date();
+            return dataLeft.date < dataRight.date;
         case FrequencyPlanningDialogModel::NAME:
         case FrequencyPlanningDialogModel::SET:
         case FrequencyPlanningDialogModel::ACTIVE:

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_frequency_planning_dialog_model.h

@@ -9,6 +9,8 @@
 #include <boost/optional.hpp>
 #include <memory>
 
+#include <AudioVideoManagement/avm_qmetatypes.h>
+
 namespace AudioVideoManagement
 {
 
@@ -68,4 +70,3 @@ class FrequencyPlanningDialogProxyModel final : public LtsWidgets::LtsColumnFilt
 };
 
 } // namespace AudioVideoManagement
-Q_DECLARE_METATYPE(AudioVideoManagement::FrequencyPlanning)

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_frequency_planning_widget.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_frequency_planning_widget.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "avm_edit_frequency_planning_set_resource_dialog.h"
 #include "avm_radio_specifica_hf_widget.h"
@@ -23,9 +24,9 @@ FrequencyPlanningWidget::FrequencyPlanningWidget(const std::shared_ptr<Interface
 {
     m_ui->setupUi(this);
 
-    m_ui->cbFrequencyBand->addItem(toString(FrequencyBand::VHF), FrequencyBand::VHF);
-    m_ui->cbFrequencyBand->addItem(toString(FrequencyBand::HF), FrequencyBand::HF);
-    m_ui->cbFrequencyBand->addItem(toString(FrequencyBand::UHF), FrequencyBand::UHF);
+    m_ui->cbFrequencyBand->addItem(toString(FrequencyBand::VHF), static_cast<int>(FrequencyBand::VHF));
+    m_ui->cbFrequencyBand->addItem(toString(FrequencyBand::HF), static_cast<int>(FrequencyBand::HF));
+    m_ui->cbFrequencyBand->addItem(toString(FrequencyBand::UHF), static_cast<int>(FrequencyBand::UHF));
 
     connect(m_ui->leName, &QLineEdit::textChanged, this, &FrequencyPlanningWidget::onNameChanged);
     connect(m_ui->cbFrequencyBand, qOverload<int>(&QComboBox::currentIndexChanged), this,
@@ -38,17 +39,17 @@ bool FrequencyPlanningWidget::init(LtsSession::LtsSession* session, RadioCircuit
                                    int frequencySetId, FrequencyBand ft)
 {
     m_frequencySetId = frequencySetId;
-    m_cnrConfigId = cnrConfigId.id();
-    m_hasParty = cnrConfigId.partyId() != 0;
+    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->setCurrentIndex(m_ui->cbFrequencyBand->findData(static_cast<int>(ft)));
     m_ui->cbFrequencyBand->setVisible(false);
     m_ui->lbxFrequencyBand->setVisible(false);
 
-    switch (ft.underlying())
+    switch (ft)
     {
 
         case FrequencyBand::HF: {
@@ -67,10 +68,10 @@ bool FrequencyPlanningWidget::init(LtsSession::LtsSession* session, RadioCircuit
             ft = data ? data->freqBand : FrequencyBand::VHF;
             m_isRelay = true;
 
-            m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(ft.underlying()));
+            m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(static_cast<int>(ft)));
             m_ui->cbFrequencyBand->setVisible(true);
             m_ui->lbxFrequencyBand->setVisible(true);
-            switch (ft.underlying())
+            switch (ft)
             {
                 case FrequencyBand::HF:
                     createHFWidget(data);
@@ -88,7 +89,7 @@ bool FrequencyPlanningWidget::init(LtsSession::LtsSession* session, RadioCircuit
         }
     }
 
-    m_ismCbxIfc->fillRadioStationsComboBox(m_ui->cbRadioStation, ft.underlying());
+    m_ismCbxIfc->fillRadioStationsComboBox(m_ui->cbRadioStation, static_cast<int>(ft));
     if (m_hasParty && !m_isRelay)
         m_ui->cbRadioStation->addItem(tr("Automatic"), 0);
     if (!data)
@@ -117,7 +118,7 @@ void FrequencyPlanningWidget::setRelaisRestrictions(bool restrict)
 {
     if (restrict)
     {
-        m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(FrequencyBand::VHF));
+        m_ui->cbFrequencyBand->setCurrentIndex(m_ui->cbFrequencyBand->findData(static_cast<int>(FrequencyBand::VHF)));
         m_ui->cbFrequencyBand->setEnabled(false);
     }
     else
@@ -152,13 +153,13 @@ void FrequencyPlanningWidget::onFrequencyBandChanged()
 {
     switch (m_ui->cbFrequencyBand->currentData().toInt())
     {
-        case FrequencyBand::HF:
+        case static_cast<int>(FrequencyBand::HF):
             createHFWidget();
             break;
-        case FrequencyBand::UHF:
+        case static_cast<int>(FrequencyBand::UHF):
             createUHFWidget();
             break;
-        case FrequencyBand::VHF:
+        case static_cast<int>(FrequencyBand::VHF):
             createVHFWidget();
             break;
     }
@@ -222,9 +223,9 @@ void FrequencyPlanningWidget::onCnrConfigChanged(const AudioVideoManagement::Cnr
                                                  DataModification modType)
 {
     Q_UNUSED(modType);
-    if (m_cnrConfigId == config.id())
+    if (m_cnrConfigId == config.id)
     {
-        m_ui->leName->setText(QString::fromStdString(config.radioCircuit()));
+        m_ui->leName->setText(QString::fromStdString(config.radioCircuit));
     }
 }
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_init_frequency_planning_dialog.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_init_frequency_planning_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include "ui_avm_init_frequency_planning_dialog.h"
 
@@ -14,6 +15,7 @@ InitFrequencyPlanningDialog::InitFrequencyPlanningDialog(LtsSession::LtsSession*
                                                          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)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     DEBUG_LOG(m_logger) << "---InitFrequencyPlanningDialog() ";
     m_ui->setupUi(this);
@@ -21,7 +23,7 @@ InitFrequencyPlanningDialog::InitFrequencyPlanningDialog(LtsSession::LtsSession*
     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()));
+        m_ui->cbFrequencySets->addItem(QString::fromStdString(it.value().name), QVariant::fromValue(it.key()));
 
     m_ui->tbTime->setText(DTG::toStringMSec(m_dateOfCreation));
 
@@ -51,12 +53,12 @@ bool InitFrequencyPlanningDialog::apply()
 {
     FrequencyPlanning planning;
 
-    planning.id(0);
+    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.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);
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_init_frequency_planning_dialog.h

@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include <AudioVideoManagement/avm_qmetatypes.h>
 #include <AudioVideoManagement/avm_dtc.h>
 #include <AudioVideoManagement/logger.h>
 #include <LtsWidgets/lts_dialog.h>

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_load_frequency_planning_dialog.cpp

@@ -2,6 +2,7 @@
 
 
 #include "avm_load_frequency_planning_dialog.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 #include "ui_avm_load_frequency_planning_dialog.h"
 
 #include "avm_load_frequency_planning_dialog_model.h"
@@ -13,6 +14,7 @@ LoadFrequencyPlanningDialog::LoadFrequencyPlanningDialog(const QByteArray &data,
   : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
   , m_ui(new Ui::LoadFrequencyPlanningDialog)
   , m_model(new LoadFrequencyPlanningDialogModel(initPlan, avmDtc, ismDtc, this))
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
   m_ui->setupUi(this);
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_load_frequency_planning_dialog_model.cpp

@@ -1,6 +1,7 @@
 
 
 #include "avm_load_frequency_planning_dialog_model.h"
+#include <NGLLogger/NGLLoggerBootstrap.h>
 
 #include <AudioVideoManagement/avm_translation.h>
 #include <FileManagement/flm_translation.h>
@@ -23,10 +24,10 @@ void LoadFrequencyPlanningDialogModel::onFrequencyPlanningChanged(const Frequenc
 {
     Q_UNUSED(dm)
 
-    if (initPlanning.exerciseId().is_set() && initPlanning.exerciseId().get() != m_exerciseId)
+    if (initPlanning.exerciseId.has_value() && initPlanning.exerciseId.get() != m_exerciseId)
         return;
 
-    if (m_exerciseId > 0 && initPlanning.exerciseId().is_set() && initPlanning.id() != m_initPlan.id())
+    if (m_exerciseId > 0 && initPlanning.exerciseId.has_value() && initPlanning.id != m_initPlan.id)
         return;
 
     beginResetModel();
@@ -39,7 +40,7 @@ void LoadFrequencyPlanningDialogModel::onFrequencyPlanningChanged(const Frequenc
             continue;
         ItemData id = item->data().value<ItemData>();
 
-        if (m_exerciseId == 0 && !initPlanning.exerciseId().is_set())
+        if (m_exerciseId == 0 && !initPlanning.exerciseId.has_value())
         {
             id.clearRadioCircuit();
             item->setData(QVariant::fromValue(id));
@@ -50,10 +51,10 @@ void LoadFrequencyPlanningDialogModel::onFrequencyPlanningChanged(const Frequenc
         if (m_exerciseId > 0)
         {
 
-            if (initPlanning.exerciseId().is_set())
+            if (initPlanning.exerciseId.has_value())
             {
 
-                if (id.cnrConfig.exerciseId().is_set())
+                if (id.cnrConfig.exerciseId.has_value())
                 {
                     id.clearRadioCircuit();
                     item->setData(QVariant::fromValue(id));
@@ -64,7 +65,7 @@ void LoadFrequencyPlanningDialogModel::onFrequencyPlanningChanged(const Frequenc
             else
             {
 
-                if (!id.cnrConfig.exerciseId().is_set())
+                if (!id.cnrConfig.exerciseId.has_value())
                 {
                     id.clearRadioCircuit();
                     item->setData(QVariant::fromValue(id));
@@ -80,22 +81,22 @@ void LoadFrequencyPlanningDialogModel::onFrequencyPlanningChanged(const Frequenc
     for (const auto& frequencyPlanning : std::as_const(frequencyPlannings))
     {
 
-        if ((initPlanning.exerciseId().is_set() && frequencyPlanning.exerciseId().is_set()) ||
-            (!initPlanning.exerciseId().is_set() && frequencyPlanning.exerciseId().is_set() &&
-             frequencyPlanning.exerciseId().get() != m_exerciseId))
+        if ((initPlanning.exerciseId.has_value() && frequencyPlanning.exerciseId.has_value()) ||
+            (!initPlanning.exerciseId.has_value() && frequencyPlanning.exerciseId.has_value() &&
+             frequencyPlanning.exerciseId.get() != m_exerciseId))
             continue;
 
-        for (const auto& frequencyPlanningData : frequencyPlanning.data())
+        for (const auto& frequencyPlanningData : frequencyPlanning.data)
         {
-            m_frequencyPlanningData.insert(frequencyPlanningData.cnrConfigId(), frequencyPlanningData);
+            m_frequencyPlanningData.insert(frequencyPlanningData.cnrConfigId, frequencyPlanningData);
             setFrequencyPlanningData(frequencyPlanningData);
         }
         break;
     }
 
-    for (const auto& frequencyPlanningData : initPlanning.data())
+    for (const auto& frequencyPlanningData : initPlanning.data)
     {
-        m_frequencyPlanningData.insert(frequencyPlanningData.cnrConfigId(), frequencyPlanningData);
+        m_frequencyPlanningData.insert(frequencyPlanningData.cnrConfigId, frequencyPlanningData);
         setFrequencyPlanningData(frequencyPlanningData);
     }
     endResetModel();
@@ -124,18 +125,19 @@ LoadFrequencyPlanningDialogModel::LoadFrequencyPlanningDialogModel(
                        tr("Squelch"),
                    }),
       m_avmDtc(avmDtc), m_ismDtc(ismDtc), m_initPlan(initPlan), m_parentPlan(initPlan),
-      m_exerciseId(initPlan.exerciseId().is_set() ? initPlan.exerciseId().get() : 0)
+      m_exerciseId(initPlan.exerciseId.has_value() ? initPlan.exerciseId.get() : 0)
+, m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
 {
     Q_ASSERT(avmDtc);
     DEBUG_LOG(m_logger) << "---EditFrequencyPlanningDataMod m_frequencyPlanningData[c.id()];el() ";
 
-    m_initPlan.data().clear();
+    m_initPlan.data.clear();
 
-    int frequencySetId = m_initPlan.frequencySetId();
-    std::vector<FrequencySetDataWithId> fsdVec = m_avmDtc->frequencySet(frequencySetId).data();
+    int frequencySetId = m_initPlan.frequencySetId;
+    std::vector<FrequencySetDataWithId> fsdVec = m_avmDtc->frequencySet(frequencySetId).data;
     for (FrequencySetDataWithId fsd : fsdVec)
     {
-        m_freqSetData.insert(fsd.id(), fsd);
+        m_freqSetData.insert(fsd.id, fsd);
     }
     onFrequencyPlanningChanged(m_initPlan, DataModification::eAdded);
 
@@ -150,7 +152,7 @@ void LoadFrequencyPlanningDialogModel::setData(const QByteArray& data)
     using namespace LtsUtils;
     const JsonObject obj = JsonObject::fromJson(data);
 
-    if (m_initPlan.frequencySetId() != obj.value<int>("frequencySetId"))
+    if (m_initPlan.frequencySetId != obj.value<int>("frequencySetId"))
     {
         ERROR_LOG(m_logger) << "false frequency set!";
 
@@ -158,7 +160,7 @@ void LoadFrequencyPlanningDialogModel::setData(const QByteArray& data)
     }
 
     beginResetModel();
-    m_initPlan.data().clear();
+    m_initPlan.data.clear();
     for (const JsonObject& association : obj.value<std::vector<JsonObject>>("planningInfos"))
     {
         FrequencyPlanningData info;
@@ -172,27 +174,27 @@ void LoadFrequencyPlanningDialogModel::setData(const QByteArray& data)
                 ;
             CnrConfig invalidConfig;
 
-            invalidConfig.id(cnrConfigId);
-            invalidConfig.cnrChannelId(channelId);
+            invalidConfig.id = cnrConfigId;
+            invalidConfig.cnrChannelId = channelId;
 
             m_cnrConfigs.insert(cnrConfigId, invalidConfig);
         }
 
-        info.cnrConfigId(cnrConfigId);
-        info.properties(association.value<QString>("properties").toStdString());
+        info.cnrConfigId = cnrConfigId;
+        info.properties = association.value<QString>("properties").toStdString();
 
         m_frequencyPlanningData.insert(cnrConfigId, info);
 
-        m_initPlan.data().push_back(info);
+        m_initPlan.data.push_back(info);
 
         const CnrConfig cnrConfig = m_cnrConfigs.value(cnrConfigId);
 
         ItemData id(cnrConfig);
-        if (m_frequencyPlanningData.contains(cnrConfig.id()))
+        if (m_frequencyPlanningData.contains(cnrConfig.id))
         {
             FrequencyPlanningData fpd = info;
-            id.readOnly = isReadOnly(fpd.properties());
-            QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
+            id.readOnly = isReadOnly(fpd.properties);
+            QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties);
 
             if (circuits.size() > 1)
             {
@@ -241,7 +243,7 @@ LoadFrequencyPlanningDialogModel::ItemData LoadFrequencyPlanningDialogModel::ite
 
 QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int role) const
 {
-    if ((role != Qt::DisplayRole && role != Qt::ToolTipRole && role != Qt::UserRole && role != Qt::TextColorRole &&
+    if ((role != Qt::DisplayRole && role != Qt::ToolTipRole && role != Qt::UserRole && role != Qt::ForegroundRole &&
          role != Qt::BackgroundRole && role != Qt::CheckStateRole) ||
         !index.isValid())
         return NGLTreeModel::data(index, role);
@@ -283,7 +285,7 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
             case FUNCTION: {
                 if (!rc)
                     return QStringLiteral("-");
-                return QString::fromStdString(m_freqSetData[rc->frequencySetDataId()].function());
+                return QString::fromStdString(m_freqSetData[rc->frequencySetDataId()].function);
             }
             case DEVICE: {
 
@@ -292,7 +294,7 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
                 RadioCircuitVHF* rcVhf = dynamic_cast<RadioCircuitVHF*>(rc);
                 if (!rcVhf)
                     return QStringLiteral("-");
-                return toString(m_freqSetData[rc->frequencySetDataId()].frequencyBand().underlying());
+                return toString(m_freqSetData[rc->frequencySetDataId()].frequencyBand);
             }
             case FREQUENCY: {
                 QLocale locale(QLocale::German);
@@ -304,7 +306,7 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
                     if (rcVhf && isAkwMode(rcVhf->operatingMode))
                         return QStringLiteral("-");
                     return tr("%1 MHz").arg(
-                        locale.toString(m_freqSetData[rc->frequencySetDataId()].frequency() / 1000., 'f', 3));
+                        locale.toString(m_freqSetData[rc->frequencySetDataId()].frequency / 1000., 'f', 3));
                 }
                 else
                 {
@@ -324,45 +326,45 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].akwBundle().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].akwBundle.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].akwBundle().get();
+                return m_freqSetData[rc->frequencySetDataId()].akwBundle.get();
             }
             case FSB_BUNDLE: {
                 if (!rc)
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].fsbBundle().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].fsbBundle.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].fsbBundle().get();
+                return m_freqSetData[rc->frequencySetDataId()].fsbBundle.get();
             }
             case AKW_RADIO_CIRCUIT: {
                 if (!rc)
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit().get();
+                return m_freqSetData[rc->frequencySetDataId()].akwRadioCircuit.get();
             }
             case COMSEC: {
                 if (!rc)
                     return QStringLiteral("-");
                 if (rc->frequencySetDataId() <= 0)
                     return QStringLiteral("-");
-                if (!m_freqSetData[rc->frequencySetDataId()].comsec().is_set())
+                if (!m_freqSetData[rc->frequencySetDataId()].comsec.has_value())
                     return QStringLiteral("-");
 
-                return m_freqSetData[rc->frequencySetDataId()].comsec().get();
+                return m_freqSetData[rc->frequencySetDataId()].comsec.get();
             }
 
             case RADIO_CIRCUIT: {
                 if (!rc)
-                    return QString::fromStdString(setData.radioCircuit());
+                    return QString::fromStdString(setData.radioCircuit);
 
                 return id.name();
             }
@@ -373,7 +375,7 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
                 if (rc->radioStationId == 0)
                     return tr("Automatic");
                 else
-                    return QString::fromStdString(m_ismDtc->mainStructureElement(rc->radioStationId).name());
+                    return QString::fromStdString(m_ismDtc->mainStructureElement(rc->radioStationId).name);
             }
             case PILOTTON: {
                 if (!rc)
@@ -396,8 +398,8 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
                 return toString(rcVhf->operatingMode);
             }
             case CHANNEL: {
-                CnrChannel channel = m_avmDtc->cnrChannel(setData.cnrChannelId());
-                return QString::fromStdString(channel.name());
+                CnrChannel channel = m_avmDtc->cnrChannel(setData.cnrChannelId);
+                return QString::fromStdString(channel.name);
             }
             case PROPERTIES: {
                 if (!rc)
@@ -462,14 +464,14 @@ QVariant LoadFrequencyPlanningDialogModel::data(const QModelIndex& index, int ro
     }
 
     if (role == Qt::UserRole)
-        return setData.id();
+        return setData.id;
 
-    if (role == Qt::TextColorRole)
+    if (role == Qt::ForegroundRole)
     {
 
         for (int id : m_multipleAssignedCnrIds)
         {
-            if (id == setData.id())
+            if (id == setData.id)
                 return QColor(Qt::red);
         }
     }
@@ -533,12 +535,12 @@ int LoadFrequencyPlanningDialogModel::findCnrConfigByChannelId(int32_t channelId
     int id = -1;
     std::function<bool(const CnrConfig&)> findByChannelIdInExercise = [this, channelId,
                                                                        &id](const CnrConfig& cnrConfig) {
-        if (cnrConfig.exerciseId().is_set() && cnrConfig.exerciseId() != m_exerciseId)
+        if (cnrConfig.exerciseId.has_value() && cnrConfig.exerciseId != m_exerciseId)
             return false;
-        if (cnrConfig.cnrChannelId() != channelId)
+        if (cnrConfig.cnrChannelId != channelId)
             return false;
 
-        id = cnrConfig.id();
+        id = cnrConfig.id;
         return true;
     };
 
@@ -570,7 +572,7 @@ void LoadFrequencyPlanningDialogModel::checkConflicts()
         {
             ItemData itemData = treeItem->data().value<ItemData>();
 
-            if (!isCnrChannelInOwnConfig(itemData.cnrConfig.cnrChannelId()))
+            if (!isCnrChannelInOwnConfig(itemData.cnrConfig.cnrChannelId))
             {
                 m_conflicts.insert(row, CHANNEL_NOT_IN_CNR_CONFIG);
                 emit dataChanged(rowIndex, rowIndex, {Qt::BackgroundRole, Qt::DisplayRole});
@@ -627,9 +629,9 @@ bool LoadFrequencyPlanningDialogModel::isCnrChannelInOwnConfig(int32_t channelId
     for (auto it = m_existingCnrConfigs.constBegin(); it != m_existingCnrConfigs.constEnd(); ++it)
     {
         const CnrConfig cnrConfig = it.value();
-        const int32_t exerciseId = cnrConfig.exerciseId().is_set() ? cnrConfig.exerciseId().get() : 0;
+        const int32_t exerciseId = cnrConfig.exerciseId.has_value() ? cnrConfig.exerciseId.get() : 0;
 
-        if (exerciseId == m_exerciseId && cnrConfig.cnrChannelId() == channelId)
+        if (exerciseId == m_exerciseId && cnrConfig.cnrChannelId == channelId)
             return true;
     }
 
@@ -647,14 +649,14 @@ bool LoadFrequencyPlanningDialogModel::isFrequencySetDataTakenInOtherExercise(in
     {
         const FrequencyPlanning frequencyPlanning = it.value();
         const int32_t currentExerciseId =
-            frequencyPlanning.exerciseId().is_set() ? frequencyPlanning.exerciseId().get() : 0;
+            frequencyPlanning.exerciseId.has_value() ? frequencyPlanning.exerciseId.get() : 0;
 
         if (currentExerciseId == m_exerciseId)
             continue;
 
-        for (const FrequencyPlanningData& data : frequencyPlanning.data())
+        for (const FrequencyPlanningData& data : frequencyPlanning.data)
         {
-            QSet<int> frequencySetDataIds = AudioVideoManagement::frequencySetDataIds(data.properties());
+            QSet<int> frequencySetDataIds = AudioVideoManagement::frequencySetDataIds(data.properties);
 
             if (frequencySetDataIds.contains(frequencySetDataId))
                 return true;
@@ -666,12 +668,12 @@ bool LoadFrequencyPlanningDialogModel::isFrequencySetDataTakenInOtherExercise(in
 
 int32_t LoadFrequencyPlanningDialogModel::parentCnrConfigIdByFrequencySetDataId(int32_t frequencySetDataId) const
 {
-    for (const FrequencyPlanningData& currentPlanning : m_parentPlan.data())
+    for (const FrequencyPlanningData& currentPlanning : m_parentPlan.data)
     {
-        QSet<int> parentFrequencySetDataIds = AudioVideoManagement::frequencySetDataIds(currentPlanning.properties());
+        QSet<int> parentFrequencySetDataIds = AudioVideoManagement::frequencySetDataIds(currentPlanning.properties);
 
         if (parentFrequencySetDataIds.contains(frequencySetDataId))
-            return currentPlanning.cnrConfigId();
+            return currentPlanning.cnrConfigId;
     }
 
     return -1;
@@ -714,10 +716,10 @@ bool LoadFrequencyPlanningDialogModel::isSolvableConflict(LoadFrequencyPlanningD
 QSet<int> LoadFrequencyPlanningDialogModel::getOwnTakenFrequencySetIds() const
 {
     QSet<int> ownTakenFrequencySetIds;
-    ownTakenFrequencySetIds.reserve(m_parentPlan.data().size() * 2);
+    ownTakenFrequencySetIds.reserve(m_parentPlan.data.size() * 2);
 
-    for (const FrequencyPlanningData& data : m_parentPlan.data())
-        ownTakenFrequencySetIds += AudioVideoManagement::frequencySetDataIds(data.properties());
+    for (const FrequencyPlanningData& data : m_parentPlan.data)
+        ownTakenFrequencySetIds += AudioVideoManagement::frequencySetDataIds(data.properties);
 
     return ownTakenFrequencySetIds;
 }
@@ -733,10 +735,10 @@ void LoadFrequencyPlanningDialogModel::addUnassignmentForRow(int32_t unassignmen
 void LoadFrequencyPlanningDialogModel::setFrequencyPlanningData(const FrequencyPlanningData& fpd)
 {
     beginResetModel();
-    ConfigTreeItem* item = searchCnrConfig(m_rootItem, fpd.cnrConfigId());
+    ConfigTreeItem* item = searchCnrConfig(m_rootItem, fpd.cnrConfigId);
     if (!item)
         return;
-    QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties());
+    QVector<RadioCircuit*> circuits = AudioVideoManagement::fromJson(fpd.properties);
     ItemData data = item->data().value<ItemData>();
     item->removeAllChildren();
 
@@ -744,7 +746,7 @@ void LoadFrequencyPlanningDialogModel::setFrequencyPlanningData(const FrequencyP
     {
         data.radioCircuit = circuits[0];
         item->setData(QVariant::fromValue(data));
-        m_frequencyPlanningData.insert(fpd.cnrConfigId(), fpd);
+        m_frequencyPlanningData.insert(fpd.cnrConfigId, fpd);
     }
     if (circuits.size() <= 1)
         return;
@@ -755,7 +757,7 @@ void LoadFrequencyPlanningDialogModel::setFrequencyPlanningData(const FrequencyP
         ConfigTreeItem* childItem = new ConfigTreeItem(QVariant::fromValue(data));
         insertRow(item->childCount(), indexFromItem(item), childItem);
     }
-    m_frequencyPlanningData.insert(fpd.cnrConfigId(), fpd);
+    m_frequencyPlanningData.insert(fpd.cnrConfigId, fpd);
     endResetModel();
 }
 
@@ -819,7 +821,7 @@ QVector<FrequencyPlanningData> LoadFrequencyPlanningDialogModel::planningData()
 
         ItemData itemData = item->data().value<ItemData>();
 
-        planningDataVec.append(m_frequencyPlanningData.value(itemData.cnrConfig.id()));
+        planningDataVec.append(m_frequencyPlanningData.value(itemData.cnrConfig.id));
     }
 
     return planningDataVec;
@@ -847,7 +849,7 @@ LoadFrequencyPlanningDialogModel::searchCnrConfig(const NGLTreeItem* parentItem,
     for (int r = 0; r < rowCount; ++r)
     {
         ConfigTreeItem* child = static_cast<ConfigTreeItem*>(parentItem->child(r));
-        if (child->data().value<ItemData>().cnrConfig.id() == cnrConfigId)
+        if (child->data().value<ItemData>().cnrConfig.id == cnrConfigId)
             return child;
         child = searchCnrConfig(child, cnrConfigId);
         if (child)
@@ -857,7 +859,7 @@ LoadFrequencyPlanningDialogModel::searchCnrConfig(const NGLTreeItem* parentItem,
 }
 
 DrawDelegate::DrawDelegate(QObject* parent)
-    : QStyledItemDelegate(parent), m_logger(NGL::NGLLoggerBootstrap::getNGLRootLogger())
+    : QStyledItemDelegate(parent)
 {
 }
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_load_frequency_planning_dialog_model.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <AudioVideoManagement/avm_qmetatypes.h>
 #include <nglwidgets/ngltreeitem.h>
 #include <AudioVideoManagement/logger.h>
 #include "avm_frequency_planning_helper.h"

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_radio_specifica_hf_widget.cpp

@@ -25,7 +25,7 @@ RadioSpecificaHfWidget::RadioSpecificaHfWidget(QWidget *parent)
   
 
   
-  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacingHF::CS_100_Hz),  ChannelSpacingHF::CS_100_Hz);
+  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacingHF::CS_100_Hz), static_cast<int>(ChannelSpacingHF::CS_100_Hz));
 
 
   
@@ -57,7 +57,7 @@ bool RadioSpecificaHfWidget::setValues(RadioCircuit *rc)
   
 
   
-  int idx = m_ui->cobChannelSpacing->findData(static_cast<int>(spec->channelSpacing.underlying()));
+  int idx = m_ui->cobChannelSpacing->findData(static_cast<int>(spec->channelSpacing));
   m_ui->cobChannelSpacing->setCurrentIndex(idx);
   succ &= (idx >= 0);
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_radio_specifica_uhf_widget.cpp

@@ -21,9 +21,9 @@ RadioSpecificaUhfWidget::RadioSpecificaUhfWidget(QWidget *parent)
 
   
   m_ui->rbMtAm->setProperty("myIcon", QStringLiteral(":/style/AM.svg"));
-  m_ui->rbMtAm->setProperty("enum", ModulationType::AM);
+  m_ui->rbMtAm->setProperty("enum", static_cast<int>(ModulationType::AM));
   m_ui->rbMtFm->setProperty("myIcon", QStringLiteral(":/style/FM.svg"));
-  m_ui->rbMtFm->setProperty("enum", ModulationType::FM);
+  m_ui->rbMtFm->setProperty("enum", static_cast<int>(ModulationType::FM));
 
   m_ui->rbMtAm->setChecked(true);
   connect(m_ui->bgModulationType, QOverload<QAbstractButton *, bool>::of(&QButtonGroup::buttonToggled), this, [this](QAbstractButton *btn, bool checked)
@@ -36,9 +36,9 @@ RadioSpecificaUhfWidget::RadioSpecificaUhfWidget(QWidget *parent)
 
 
   
-  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacing::CS_25_00_kHz),  ChannelSpacing::CS_25_00_kHz);
-  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacing::CS_12_50_kHz),  ChannelSpacing::CS_12_50_kHz);
-  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacing::CS_8_33_kHz),   ChannelSpacing::CS_8_33_kHz);
+  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacing::CS_25_00_kHz), static_cast<int>(ChannelSpacing::CS_25_00_kHz));
+  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacing::CS_12_50_kHz), static_cast<int>(ChannelSpacing::CS_12_50_kHz));
+  m_ui->cobChannelSpacing->addItem(toString(ChannelSpacing::CS_8_33_kHz), static_cast<int>(ChannelSpacing::CS_8_33_kHz));
 
   
   LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
@@ -86,7 +86,7 @@ bool RadioSpecificaUhfWidget::setValues(RadioCircuit* rc)
 
   bool succ = true;
   
-  switch(spec->modulationType.underlying())
+  switch(spec->modulationType)
   {
   case ModulationType::FM:
     m_ui->rbMtFm->setChecked(true);
@@ -100,7 +100,7 @@ bool RadioSpecificaUhfWidget::setValues(RadioCircuit* rc)
   }
 
   
-  int idx = m_ui->cobChannelSpacing->findData(static_cast<int>(spec->channelSpacing.underlying()));
+  int idx = m_ui->cobChannelSpacing->findData(static_cast<int>(spec->channelSpacing));
   m_ui->cobChannelSpacing->setCurrentIndex(idx);
   succ &= (idx >= 0);
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/FrequencyPlanning/avm_radio_specifica_vhf_widget.cpp

@@ -22,11 +22,11 @@ RadioSpecificaVhfWidget::RadioSpecificaVhfWidget(QSet<int> &assignedFrequencySet
   m_ui->setupUi(this);
 
   
-  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::FixedFreqEncNone),   RcOperatingMode::FixedFreqEncNone);
-  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::FixedFreqEncHwKr),   RcOperatingMode::FixedFreqEncHwKr);
-  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::FixedFreqEncHwKrKl), RcOperatingMode::FixedFreqEncHwKrKl);
-  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::AkwEncNone),         RcOperatingMode::AkwEncNone);
-  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::AkwEncEccm),         RcOperatingMode::AkwEncEccm);
+  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::FixedFreqEncNone), static_cast<int>(RcOperatingMode::FixedFreqEncNone));
+  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::FixedFreqEncHwKr), static_cast<int>(RcOperatingMode::FixedFreqEncHwKr));
+  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::FixedFreqEncHwKrKl), static_cast<int>(RcOperatingMode::FixedFreqEncHwKrKl));
+  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::AkwEncNone), static_cast<int>(RcOperatingMode::AkwEncNone));
+  m_ui->cobOperatingMode->addItem(toString(RcOperatingMode::AkwEncEccm), static_cast<int>(RcOperatingMode::AkwEncEccm));
 
   
   m_ui->leFrequencySet->setEnabled(false);
@@ -62,12 +62,12 @@ bool RadioSpecificaVhfWidget::setFrequencySetData(int frequencySetDataId)
   m_frequencySetDataId = frequencySetDataId;
   m_ui->leFrequencySet->clear();
   bool found = false;
-  std::vector<FrequencySetDataWithId> dataVec = m_avmDtc->frequencySet(m_frequencySetId).data();
+  std::vector<FrequencySetDataWithId> dataVec = m_avmDtc->frequencySet(m_frequencySetId).data;
   for (const auto &it : dataVec)
   {
-    if(it.id() == m_frequencySetDataId)
+    if(it.id == m_frequencySetDataId)
     {
-      m_ui->leFrequencySet->setText(QString::fromStdString(it.function()));
+      m_ui->leFrequencySet->setText(QString::fromStdString(it.function));
       found = true;
       break;
     }
@@ -85,7 +85,7 @@ bool RadioSpecificaVhfWidget::setValues(RadioCircuit* rc)
   bool succ = true;
   
   m_operatingMode = spec->operatingMode;
-  int idx = m_ui->cobOperatingMode->findData(static_cast<int>(spec->operatingMode.underlying()));
+  int idx = m_ui->cobOperatingMode->findData(static_cast<int>(spec->operatingMode));
   m_ui->cobOperatingMode->setCurrentIndex(idx);
   succ &= (idx >= 0);
 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/avm_combat_net_radio_gui_plugin.cpp

@@ -127,7 +127,7 @@ LtsWidgets::LtsDialog *InterfaceImpl::onShowFrequencyPlanningDialog(QWidget *par
 
    for(const FrequencyPlanning &planning : std::as_const(plannings))
    {
-     if(planning.exerciseId().is_set())
+     if(planning.exerciseId.has_value())
        continue;
 
     EditFrequencyPlanningDialog *dialog = new EditFrequencyPlanningDialog(m_session,

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Gui/CombatNetRadio/avm_combat_net_radio_gui_plugin.h

@@ -5,6 +5,7 @@
 
 #include <AudioVideoManagement/logger.h>
 #include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_dtc.h>
 
 
 #include <PluginInterfaces/gui_plugin_interface.h>