Qt6 Migration: Complete migration with DDS/RTI support and build validation

Major Changes:
- Merged latest Qt5 devel content from dlbo (292 files changed, 7 new dirs)
- Consolidated forward-declarations and include folders
- Removed unneeded modules per Niklas' repo check list

Build System Fixes:
- Fixed CMake VERSION_GREATER syntax in ParticipantManagement/CMakeLists.txt
- Added VLC packages (libvlc-dev, vlc-plugin-base) to docker_build.sh
- Added PostgreSQL dev packages (libpq-dev, postgresql-server-dev-all) to Dockerfile
- Fixed locale warnings (ANSI_X3.4-1968 → C.UTF-8)
- Fixed ArcGIS SDK path warnings when BUILD_ARCGIS=OFF

Code Generation Fixes:
- Fixed IDL enum collisions (PortType→CorePortType/DdsutPortType, PdmEventType)
- Fixed Grantlee template svc_translation.cpp.grantlee:
  - Changed {{ idl_enum.name }}_def:: to {{ idl_enum.name }}::
  - Fixed .underlying() calls for C++11 scoped enums (enum class)
- Removed generated files from repo (moc_*, *_dtc.h, *_ftc.h)

Validation:
- BUILD_RTI=ON: SUCCESS
- BUILD_RTI=OFF: SUCCESS
- C++17 standard maintained for RTI 7.7 compatibility
- Ubuntu 26.04 Docker environment verified

Remaining Warnings (expected):
- BgViewer, KDChart, KDReports, Poppler-Qt6 not found (optional features)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

qt5-before/dlbo/Lts/Proxies/HighLevelArchitecture/Apache/damage_model.cpp

@@ -0,0 +1,191 @@
+/**
+  * @RDE_HEADER@
+  * Damage state transaformation from/to HLA <-> Excon, see ICD, 4.4.3.5.6 - Damage Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "damage_model.h"
+
+#include <QTimer>
+#include <QDateTime>
+
+namespace HighLevelArchitecture
+{
+
+// ICD, 4.4.3.5.6 - Damage Model
+// es sind dort nich alle definiert, die Reihenfolge ist DamageState - FirePower - Immobilized
+DamageModel::DamageModel(const IdentifierStruct &is,
+                         const ProjectDataManagement::VulnerabilityState &state)
+  : m_is(is)
+{
+  initTimer();
+  setVulnerabilityState(state, QDateTime::currentMSecsSinceEpoch());
+}
+
+DamageModel::DamageModel(const ProjectDataManagement::VulnerabilityState &state)
+{
+  setVulnerabilityState(state, QDateTime::currentMSecsSinceEpoch());
+}
+
+ProjectDataManagement::VulnerabilityState DamageModel::vulnerabilityStateFromDamageStatus(const rpr2::DamageStatusEnum32::ET &status)
+{
+  ProjectDataManagement::VulnerabilityState vs;
+  switch(status)
+  {
+  case rpr2::DamageStatusEnum32::NoDamage:
+    vs = ProjectDataManagement::VulnerabilityState_def::CombatReady;
+    break;
+  case rpr2::DamageStatusEnum32::SlightDamage:
+    vs = ProjectDataManagement::VulnerabilityState_def::LightDamage;
+    break;
+  case rpr2::DamageStatusEnum32::ModerateDamage:
+    vs = ProjectDataManagement::VulnerabilityState_def::HeavyDamage;
+    break;
+  case rpr2::DamageStatusEnum32::Destroyed:
+    vs = ProjectDataManagement::VulnerabilityState_def::CatastrophicKill;
+    break;
+  }
+
+  return vs;
+}
+
+DamageModel::DamageModel(const IdentifierStruct &is, const rpr2::DamageStatusEnum32::ET &status)
+  : m_is(is)
+{
+  ProjectDataManagement::VulnerabilityState vs = vulnerabilityStateFromDamageStatus(status);
+  setVulnerabilityState(vs, QDateTime::currentMSecsSinceEpoch());
+
+}
+
+rpr2::DamageStatusEnum32::ET DamageModel::damageState(qint64 simTimeMSec) const
+{
+  int idx = indexForTime(simTimeMSec);
+  if (idx < 0)
+    return rpr2::DamageStatusEnum32::NoDamage;
+
+  // Todo: Correct?!?
+  switch (m_vulnerabilityStates.at(idx).vulnerabilityState.underlying())
+  {
+  case ProjectDataManagement::VulnerabilityState_def::CombatReady:
+    return rpr2::DamageStatusEnum32::NoDamage;
+  case ProjectDataManagement::VulnerabilityState_def::LightDamage:
+    return rpr2::DamageStatusEnum32::SlightDamage;
+  case ProjectDataManagement::VulnerabilityState_def::MediumDamage:
+  case ProjectDataManagement::VulnerabilityState_def::HeavyDamage:
+  case ProjectDataManagement::VulnerabilityState_def::MobilityKill:
+  case ProjectDataManagement::VulnerabilityState_def::VisibleMobilityKill:
+  case ProjectDataManagement::VulnerabilityState_def::WeaponSystemDamage:
+  case ProjectDataManagement::VulnerabilityState_def::VisibleWeaponSystemDamage:
+    return rpr2::DamageStatusEnum32::ModerateDamage;
+  case ProjectDataManagement::VulnerabilityState_def::CatastrophicKill:
+    return rpr2::DamageStatusEnum32::Destroyed;
+  case ProjectDataManagement::VulnerabilityState_def::TemporarySeverance:
+  case ProjectDataManagement::VulnerabilityState_def::NearMiss:
+  case ProjectDataManagement::VulnerabilityState_def::HitWithNoEffect:
+    return rpr2::DamageStatusEnum32::NoDamage;
+  case ProjectDataManagement::VulnerabilityState_def::VulnerabilityBitsChanged:
+  case ProjectDataManagement::VulnerabilityState_def::Reserved:
+    return rpr2::DamageStatusEnum32::NoDamage;
+  case ProjectDataManagement::VulnerabilityState_def::NContamination:
+  case ProjectDataManagement::VulnerabilityState_def::BContamination:
+  case ProjectDataManagement::VulnerabilityState_def::CContamination:
+    return rpr2::DamageStatusEnum32::SlightDamage;
+  case ProjectDataManagement::VulnerabilityState_def::NotReady:
+    return rpr2::DamageStatusEnum32::NoDamage;
+  }
+  return rpr2::DamageStatusEnum32::NoDamage;
+}
+
+bool DamageModel::immobilized(qint64 simTimeMSec) const
+{
+  int idx = indexForTime(simTimeMSec);
+  if (idx < 0)
+    return false;
+  if (m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::MobilityKill ||
+      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::VisibleMobilityKill ||
+      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::CatastrophicKill)
+    return true;
+  return false;
+}
+
+bool DamageModel::firePowerDisabled(qint64 simTimeMSec) const
+{
+  int idx = indexForTime(simTimeMSec);
+  if (idx < 0)
+    return false;
+  if (m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::WeaponSystemDamage ||
+      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::VisibleWeaponSystemDamage ||
+      m_vulnerabilityStates.at(idx).vulnerabilityState == ProjectDataManagement::VulnerabilityState_def::CatastrophicKill)
+    return true;
+  return false;
+}
+
+void DamageModel::setVulnerabilityState(const ProjectDataManagement::VulnerabilityState &state, qint64 simTimeMSec)
+{
+  const int idx = indexForTime(simTimeMSec);
+  if (idx > 0 && m_vulnerabilityStates.at(idx).timeStamp == simTimeMSec)
+  {
+    // already there...
+    if (state == m_vulnerabilityStates.at(idx).vulnerabilityState)
+      return;
+    m_vulnerabilityStates[idx].vulnerabilityState = state;
+  }
+  else
+  {
+    VulnerabilityStateStructWithTimeStamp vssTs;
+    vssTs.vulnerabilityState = state;
+    vssTs.timeStamp = simTimeMSec;
+    m_vulnerabilityStates.insert(idx + 1, std::move(vssTs)); // idx = -1 -> oldest, will become index 0
+  }
+
+  while (m_vulnerabilityStates.size() > 10)
+    m_vulnerabilityStates.pop_front();
+}
+
+void DamageModel::setDamageState(const rpr2::DamageStatusEnum32::ET state, qint64 simTimeMSec)
+{
+  ProjectDataManagement::VulnerabilityState vs = vulnerabilityStateFromDamageStatus(state);
+  setVulnerabilityState(vs, simTimeMSec);
+}
+
+ProjectDataManagement::VulnerabilityState DamageModel::vulnerabilityState(qint64 simTimeMSec) const
+{
+  int idx = indexForTime(simTimeMSec);
+  if (idx < 0)
+    return ProjectDataManagement::VulnerabilityState_def::CombatReady;
+  return m_vulnerabilityStates.at(idx).vulnerabilityState;
+}
+
+int DamageModel::indexForTime(qint64 simTimeMSec) const
+{
+  const int s = m_vulnerabilityStates.size();
+  if (simTimeMSec < 0 && s != 0)  // = use current
+    return s - 1;
+
+  for (int i = s - 1; i >= 0; --i)
+  {
+    const auto &tss = m_vulnerabilityStates.at(i);
+    if (tss.timeStamp <= simTimeMSec)
+      return i;
+  }
+  return -1;
+}
+
+void DamageModel::initTimer()
+{
+  delete m_timer;
+  m_timer = new QTimer(this);
+  m_timer->setSingleShot(true);
+  m_timer->start(s_waitInterval);
+  connect(m_timer, &QTimer::timeout,
+          this, [this]()
+  {
+    emit damageStateChanged();
+    m_timer->deleteLater();
+    m_timer = nullptr;
+  });
+}
+
+} // namespace HighLevelArchitecture