Merge feature/lts-viewer-validation-testing-phase into feature/qt6-migration-basis-modules-merge

Resolves 1 conflict (new_docker_build.sh, union of viewer-only + codification options); folds in fixes for pre-existing defects surfaced by the validation runs (KDReports-qt6 wiring, LtsSession RTI linking, LtsFileDialog/WLS/BSM Qt6/RTI API migration, GROUP4 target list, new --cmake_build_flags option); validated with BUILD_RTI=ON BUILD_GRANTLEE=ON in 3 Docker runs (run 3: build green, 6 base-state first-run CTest failures documented).

ci/allowed_signers

@@ -1 +1,2 @@
 torsten.wierschin@life-maps.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIMV8yH39fMOQE5BeCsxI8RMUXbDBJvRuS5phTTfrXF0H
+berrux.kana@axilinx.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJ6kKREEjPzWMq8zjhIUCeiPI1MtwVHiZHaKxkePmW4t berrux.kana@axilinx.com

qt6-after/qt6-migrated-legatus/.envrc

@@ -1,4 +1,4 @@
 # export MIGRATE_PIPELINE_ROOT="/home/torsten/sandbox/qt6-migration-pipeline"
-export MIGRATE_PIPELINE_ROOT="Passe Deinen Pfad an."
+export MIGRATE_PIPELINE_ROOT="/home/nkana/repo/qt6-migration-pipeline"
 export LANG=C.UTF-8
 export LC_ALL=C.UTF-8

qt6-after/qt6-migrated-legatus/.forward-declarations/include/AlarmManagement/alm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AlarmManagement/alm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/AreaEffectSimulation/aes_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AreaEffectSimulation/aes_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/AssetManagement/asm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AssetManagement/asm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/AudioVideoManagement/avm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AudioVideoManagement/avm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/Buildings/bld_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Buildings/bld_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/CentralEffectSimulation/ces_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/CentralEffectSimulation/ces_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/CodificationManagement/cod_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/CodificationManagement/cod_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ComponentMonitor/cmo_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ComponentMonitor/cmo_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/Core/core_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Core/core_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/DDS/DTC/generic_dtc.h

@@ -0,0 +1,130 @@
+
+
+#pragma once
+
+// Include Qt headers FIRST to prevent namespace pollution when RTI DDS headers include Qt
+#include <QtCore/QString>
+#include <QtCore/QUrl>
+#include <QtCore/QFlag>
+#include <LtsUtils/LtsUtilsCore/data_modification_enum.h>
+#include <dds/sub/LoanedSamples.hpp>
+
+namespace NGLLogger
+{
+class INGLLogger;
+}
+
+namespace DTC
+{
+class SubscriberListener;
+
+template <typename DRO_OBJECT, typename SC> class GenericDtcSC
+{
+  public:
+    using DataReaderObject = DRO_OBJECT;
+    using SubscriberCallback = SC;
+    using TopicType = typename DRO_OBJECT::TopicType;
+
+    GenericDtcSC() = default;
+    virtual ~GenericDtcSC() = default;
+
+    virtual bool setSubscriberCallback(const SubscriberCallback& subscriberCallback) = 0;
+    virtual dds::sub::LoanedSamples<TopicType> readAlive() const = 0;
+    virtual bool readAlive(TopicType& data) = 0;
+    virtual dds::sub::LoanedSamples<TopicType> takeAlive() const = 0;
+    virtual bool takeAlive(TopicType& data) = 0;
+    virtual dds::sub::LoanedSamples<TopicType> takeDisposed() const = 0;
+    virtual bool takeDisposed(TopicType& data) = 0;
+    virtual bool hasSamples() const = 0;
+    virtual DataReaderObject* dataReader() const = 0;
+    virtual bool waitForHistoricalData(int timeoutMSec) = 0;
+};
+
+template <typename DRO_OBJECT>
+class GenericDtc
+    : public GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, DataModification)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, DataModification)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    using BaseClass::SubscriberCallback;
+    bool setSubscriberCallback(const typename BaseClass::SubscriberCallback& callback) override { return BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+
+template <typename DRO_OBJECT>
+class GenericDtcSampleInfo
+    : public GenericDtcSC<DRO_OBJECT,
+                          std::function<void(const typename DRO_OBJECT::TopicType&, const dds::sub::SampleInfo&)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const dds::sub::SampleInfo&)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    void setSubscriberCallback(std::function<void(const TopicType&, const dds::sub::SampleInfo&)> callback) { BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+
+template <typename DRO_OBJECT>
+class Ddtc
+    : public GenericDtcSC<
+          DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&, DataModification)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&, DataModification)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    void setSubscriberCallback(std::function<void(const TopicType&, const std::string&, DataModification)> callback) { BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+
+template <typename DRO_OBJECT>
+class DdtcSampleInfo
+    : public GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&,
+                                                         const dds::sub::SampleInfo&)>>
+{
+  public:
+    using BaseClass = GenericDtcSC<DRO_OBJECT, std::function<void(const typename DRO_OBJECT::TopicType&, const std::string&, const dds::sub::SampleInfo&)>>;
+    using TopicType = typename BaseClass::TopicType;
+    
+    // Explicitly expose base class methods for accessibility through smart pointers
+    using BaseClass::readAlive;
+    using BaseClass::takeAlive;
+    using BaseClass::takeDisposed;
+    void setSubscriberCallback(std::function<void(const TopicType&, const std::string&, const dds::sub::SampleInfo&)> callback) { BaseClass::setSubscriberCallback(callback); }
+    bool readAlive(TopicType& data) { return BaseClass::readAlive(data); }
+    bool takeAlive(TopicType& data) { return BaseClass::takeAlive(data); }
+    bool takeDisposed(TopicType& data) { return BaseClass::takeDisposed(data); }
+    bool hasSamples() const { return BaseClass::hasSamples(); }
+    std::shared_ptr<DRO_OBJECT> dataReader() { return BaseClass::dataReader(); }
+    bool waitForHistoricalData(int timeoutMSec) { return BaseClass::waitForHistoricalData(timeoutMSec); }
+};
+} // namespace DTC

qt6-after/qt6-migrated-legatus/.forward-declarations/include/DDS/DTC/generic_dtc_impl.h

@@ -8,10 +8,14 @@
 
 #pragma once
 
+// Include Qt headers FIRST to prevent namespace pollution when RTI DDS headers include Qt
+#include <QtCore/QString>
+#include <QtCore/QUrl>
+#include <QtCore/QFlag>
+#include <QtCore/QTimer>
 #include <DDS/Generic/generic_data_reader.h>
 #include <DDS/Generic/subscriber_listener.h>
 #include <DDS/Generic/generic_logger.h>
-#include <QTimer>
 
 #include <dds/core/cond/StatusCondition.hpp>
 #include <dds/core/cond/WaitSet.hpp>
@@ -22,7 +26,8 @@
 namespace DDSGeneric
 {
 class DynamicDataReader;
-}
+} // namespace DDSGeneric
+
 namespace DTC
 {
 
@@ -122,6 +127,17 @@ public:
     return ret;
   }
 
+  bool readAlive(TopicTypeRead& data) override final
+  {
+    auto samples = readAlive();
+    if (samples.length() > 0)
+    {
+      data = samples[0].data();
+      return true;
+    }
+    return false;
+  }
+
   dds::sub::LoanedSamples<TopicTypeRead> takeAlive() const override final
   {
     if (!m_dataReaderObject)
@@ -135,6 +151,17 @@ public:
     return ret;
   }
 
+  bool takeAlive(TopicTypeRead& data) override final
+  {
+    auto samples = takeAlive();
+    if (samples.length() > 0)
+    {
+      data = samples[0].data();
+      return true;
+    }
+    return false;
+  }
+
   dds::sub::LoanedSamples<TopicTypeRead> takeDisposed() const override final
   {
     if (!m_dataReaderObject)
@@ -143,6 +170,17 @@ public:
     return m_dataReaderObject->takeDisposed();
   }
 
+  bool takeDisposed(TopicTypeRead& data) override final
+  {
+    auto samples = takeDisposed();
+    if (samples.length() > 0)
+    {
+      data = samples[0].data();
+      return true;
+    }
+    return false;
+  }
+
   bool hasSamples() const override final
   {
     if (!m_dataReaderObject)
@@ -169,7 +207,7 @@ public:
       if (dr.subscription_matched_status().current_count() == 0)
       {
         dds::core::cond::WaitSet ws;
-        dds::core::cond::StatusCondition cond(dr);
+        auto cond = dds::core::cond::StatusCondition(dr);
         cond.enabled_statuses(dds::core::status::StatusMask::subscription_matched());
         ws.attach_condition(cond);
         const dds::core::Duration waitTimeout(bWaitForever ? dds::core::Duration::infinite() : dds::core::Duration::from_millisecs(timeoutMSec));

qt6-after/qt6-migrated-legatus/.forward-declarations/include/DDS/Generic/generic_data_reader.h

@@ -0,0 +1,173 @@
+#pragma once
+
+/**
+ * @file generic_data_reader.h
+ * @brief Generic Data Reader wrapper for DDS
+ * 
+ * Provides GenericDataReader template class that wraps RTI DataReader
+ * when BUILD_RTI=ON, or provides stub implementation when BUILD_RTI=OFF.
+ */
+
+#include <functional>
+#include <string>
+
+#ifdef BUILD_RTI
+// RTI DDS is available - include full implementation from Lts
+// MUST be included BEFORE namespace DDSGeneric to avoid namespace pollution
+#include <Lts/DDS/Generic/dynamic_data_reader.h>
+#include <Lts/DDS/Generic/generic_data_reader.h>
+
+namespace DDSGeneric
+{
+// Full implementation is in Lts/DDS/Generic/generic_data_reader.h
+// This file just provides the include path redirection
+} // namespace DDSGeneric
+
+#else
+// BUILD_RTI=OFF: Provide minimal stub definitions for RTI types
+
+namespace dds {
+namespace sub {
+namespace detail {
+
+// Dummy delegate class to serve as default template parameter
+template<typename Q>
+class DataReaderImpl {
+    // Empty stub implementation
+};
+
+} // namespace detail
+
+// Forward declaration stub for DataReader
+// Must match RTI 7.7 signature for compatibility
+template<typename T, template <typename Q> class DELEGATE = detail::DataReaderImpl>
+class DataReader {
+public:
+    // Minimal stub interface - add methods as needed by the codebase
+    T read() { return T{}; }
+    void take() {}
+};
+
+} // namespace sub
+} // namespace dds
+
+namespace DDSGeneric
+{
+
+// GenericDataReader stub template (only when BUILD_RTI=OFF)
+template<typename T>
+class GenericDataReader {
+public:
+    using TopicType = T;
+    using TopicTypeRead = T;
+    using DataReader = void*;
+    using DataTopic = void*;
+    using DataReaderQos = void*;
+    using SubscriberCallback = std::function<void(const TopicTypeRead&, int)>;
+    using SubscriberCallbackWithSampleInfo = std::function<void(const TopicTypeRead&, const void*)>;
+    
+    GenericDataReader()
+        : m_dataReader(nullptr), m_ddsTopic(nullptr), m_bHaveSubscriberCallback(false)
+    {
+    }
+    
+    virtual ~GenericDataReader()
+    {
+        m_ddsTopic = nullptr;
+        m_dataReader = nullptr;
+    }
+    
+    DataReader getDataReader() const
+    {
+        return m_dataReader;
+    }
+    
+    bool create(const void* domainParticipant, const void* ddsSubscriber,
+                const std::string& topicName = std::string(),
+                bool bCreateDataReader = true)
+    {
+        return false;
+    }
+    
+    bool hasSamples() const
+    {
+        return false;
+    }
+    
+    void* readAlive(bool& bSeenNewSamples)
+    {
+        bSeenNewSamples = false;
+        return nullptr;
+    }
+    
+    void* takeAlive(bool& bSeenNewSamples)
+    {
+        bSeenNewSamples = false;
+        return nullptr;
+    }
+    
+    void* takeDisposed()
+    {
+        return nullptr;
+    }
+    
+    template <typename C> bool read(C callbackFunc)
+    {
+        return false;
+    }
+    
+    void setHaveSubscriberCallback(bool bHave)
+    {
+        m_bHaveSubscriberCallback = bHave;
+    }
+    
+    std::string topicName() const
+    {
+        return std::string();
+    }
+    
+    DataReader dataReader() const
+    {
+        return m_dataReader;
+    }
+    
+    virtual void recreateReader()
+    {
+    }
+    
+protected:
+    DataReader m_dataReader;
+    DataReaderQos m_dataReaderQos;
+    DataTopic m_ddsTopic;
+    bool m_bHaveSubscriberCallback;
+};
+
+template<typename T>
+class GenericDataReaderContentFilter {
+public:
+    using DataType = T;
+    // Minimal stub - extend as needed
+};
+
+// DynamicDataReader stub for BUILD_RTI=OFF
+class DynamicDataReader {
+public:
+    using TopicType = void*;
+    using DataReader = void*;
+    using DataTopic = void*;
+    
+    DynamicDataReader() {}
+    ~DynamicDataReader() {}
+    
+    bool create(const void* domainParticipant, const void* ddsSubscriber,
+                const std::string& specialTopicName, const void* structType)
+    {
+        return false;
+    }
+    
+    bool hasSamples() const { return false; }
+};
+
+} // namespace DDSGeneric
+
+#endif // BUILD_RTI

qt6-after/qt6-migrated-legatus/.forward-declarations/include/EffectShowClient/esc_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/EffectShowClient/esc_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/EffectShowManagement/esm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/EffectShowManagement/esm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/Evaluations/evl_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Evaluations/evl_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ExerciseEventManagement/eem_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ExerciseEventManagement/eem_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ExerciseManagement/exm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ExerciseManagement/exm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/CMakeLists.txt

@@ -0,0 +1,36 @@
+# Stub CMakeLists.txt für FileManagement Headers
+# Diese Datei stellt eine leere Library bereit damit andere Module linken können
+# ohne die vollständigen DDS-basierten Services zu benötigen
+
+# FileManagement Stub Library mit Dtc-Implementierung
+add_library(FileManagement_Stub STATIC
+  flm_dtc.cpp
+)
+target_include_directories(FileManagement_Stub
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+target_link_libraries(FileManagement_Stub
+  PUBLIC
+    Qt6::Core
+)
+set_target_properties(FileManagement_Stub PROPERTIES
+  AUTOMOC ON
+)
+
+# svcFlmCommon als ALIAS zu FileManagement_Stub für Kompatibilität
+add_library(svcFlmCommon ALIAS FileManagement_Stub)
+
+# Leere Header-Only Library als Platzhalter für svcOpmCommon
+add_library(svcOpmCommon INTERFACE)
+target_include_directories(svcOpmCommon
+  INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../OperatorManagement/
+)
+
+# Leere Header-Only Library als Platzhalter für svcExmCommon
+add_library(svcExmCommon INTERFACE)
+target_include_directories(svcExmCommon
+  INTERFACE
+    ${CMAKE_CURRENT_SOURCE_DIR}/../ExerciseManagement/
+)

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_data_plugin_interface.h

@@ -0,0 +1,30 @@
+/**
+  * @RDE_HEADER@
+  * FileManagement Explorer Interface for access from other Plugins
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Mike Wille, SLSE, 2017-03-31
+  */
+
+#pragma once
+
+#include <PluginInterfaces/data_plugin_interface.h>
+#include <FileManagement/flm_dtc.h>
+#include <FileManagement/flm_ftc.h>
+
+namespace FileManagement
+{
+/**
+ * @brief The DataInterface class provides the Topics Clients only for the GUI Plugins
+ */
+class DataInterface : public DataPluginBase::Interface
+{
+public:
+  using DataPluginBase::Interface::Interface;
+
+  virtual std::shared_ptr<FileManagement::Interface::Dtc> getDtc() = 0;
+  virtual std::shared_ptr<FileManagement::Interface::Ftc> getFtc() = 0;
+};
+
+} // namespace FileManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_db.h

@@ -0,0 +1,181 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von DDS/RTI Codegen generiert
+// Für die Migration mit BUILD_RTI=OFF erstellen wir minimale Implementierungen
+
+#include "flm_enums.hpp"
+#include <QString>
+#include <QDateTime>
+#include <QByteArray>
+#include <vector>
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace FileManagement
+{
+
+// Forward declarations
+class Folder;
+class FileContent;
+
+/**
+ * @brief Folder class - Stub für DDS-generierten Code
+ * 
+ * Diese Klasse wird normalerweise von DDS aus flm_service.xml generiert.
+ * Für BUILD_RTI=OFF verwenden wir diese minimale Implementierung.
+ */
+class Folder
+{
+public:
+  Folder() : m_id(0), m_parentId(0), m_mainFolder(MainFolder::None), m_operatorId(0) {}
+  
+  // Getter
+  int32_t id() const { return m_id; }
+  std::string name() const { return m_name.toStdString(); }
+  int32_t parentId() const { return m_parentId; }
+  std::vector<int32_t> path() const { return m_path; }
+  QDateTime created() const { return m_created; }
+  QDateTime modified() const { return m_modified; }
+  MainFolder mainFolder() const { return m_mainFolder; }
+  int32_t operatorId() const { return m_operatorId; }
+  bool isHidden() const { return m_hidden; }
+  bool isEditable() const { return m_editable; }
+  bool isDeleted() const { return m_deleted; }
+  
+  // Setter
+  void setId(int32_t id) { m_id = id; }
+  void setName(const QString& name) { m_name = name; }
+  void setName(const std::string& name) { m_name = QString::fromStdString(name); }
+  void setParentId(int32_t parentId) { m_parentId = parentId; }
+  void setPath(const std::vector<int32_t>& path) { m_path = path; }
+  void setCreated(const QDateTime& created) { m_created = created; }
+  void setModified(const QDateTime& modified) { m_modified = modified; }
+  void setMainFolder(MainFolder mainFolder) { m_mainFolder = mainFolder; }
+  void setOperatorId(int32_t operatorId) { m_operatorId = operatorId; }
+  void setHidden(bool hidden) { m_hidden = hidden; }
+  void setEditable(bool editable) { m_editable = editable; }
+  void setDeleted(bool deleted) { m_deleted = deleted; }
+  
+  // Utility
+  bool isValid() const { return m_id > 0; }
+  
+private:
+  int32_t m_id;
+  QString m_name;
+  int32_t m_parentId;
+  std::vector<int32_t> m_path;
+  QDateTime m_created;
+  QDateTime m_modified;
+  MainFolder m_mainFolder;
+  int32_t m_operatorId;
+  bool m_hidden = false;
+  bool m_editable = true;
+  bool m_deleted = false;
+};
+
+/**
+ * @brief FileContent class - Stub für DDS-generierten Code
+ * 
+ * Diese Klasse wird normalerweise von DDS aus flm_service.xml generiert.
+ * Für BUILD_RTI=OFF verwenden wir diese minimale Implementierung.
+ */
+class FileContent
+{
+public:
+  FileContent()
+      : m_id(0)
+      , m_fileId(0)
+      , m_folderId(0)
+      , m_operatorId(0)
+      , m_exerciseId(std::nullopt)
+      , m_phaseId(std::nullopt)
+      , m_size(0)
+      , m_fileStatus(FileStatus::Valid)
+      , m_fileCategory(FileCategory::Global)
+      , m_fileType(FileType::Unknown)
+      , m_isTemplate(false)
+      , m_mainFolder(MainFolder::None)
+      , m_hidden(false)
+      , m_used(false)
+  {
+  }
+  
+  // Getter
+  int32_t id() const { return m_id; }
+  int32_t fileId() const { return m_fileId; }
+  int32_t folderId() const { return m_folderId; }
+  int32_t operatorId() const { return m_operatorId; }
+  std::optional<int32_t> exerciseId() const { return m_exerciseId; }
+  std::optional<int32_t> phaseId() const { return m_phaseId; }
+  QString name() const { return m_fileName; }
+  QString fileName() const { return m_fileName; }
+  QString mimeType() const { return m_mimeType; }
+  int64_t size() const { return m_size; }
+  QByteArray content() const { return m_content; }
+  std::string properties() const { return m_properties; }
+  QDateTime created() const { return m_created; }
+  QDateTime modified() const { return m_modified; }
+  QDateTime lastModified() const { return m_modified; }
+  FileStatus fileStatus() const { return m_fileStatus; }
+  FileCategory fileCategory() const { return m_fileCategory; }
+  FileType fileType() const { return m_fileType; }
+  bool isTemplate() const { return m_isTemplate; }
+  bool isDeleted() const { return m_fileStatus == FileStatus::Deleted; }
+  bool isHidden() const { return m_hidden; }
+  bool isUsedBy() const { return m_used; }
+  std::string usedBy() const { return m_usedBy; }
+  MainFolder mainFolder() const { return m_mainFolder; }
+  
+  // Setter
+  void setId(int32_t id) { m_id = id; }
+  void setFileId(int32_t fileId) { m_fileId = fileId; }
+  void setFolderId(int32_t folderId) { m_folderId = folderId; }
+  void setOperatorId(int32_t operatorId) { m_operatorId = operatorId; }
+  void setExerciseId(std::optional<int32_t> exerciseId) { m_exerciseId = exerciseId; }
+  void setPhaseId(std::optional<int32_t> phaseId) { m_phaseId = phaseId; }
+  void setName(const QString& fileName) { m_fileName = fileName; }
+  void setFileName(const QString& fileName) { m_fileName = fileName; }
+  void setMimeType(const QString& mimeType) { m_mimeType = mimeType; }
+  void setSize(int64_t size) { m_size = size; }
+  void setContent(const QByteArray& content) { m_content = content; }
+  void setProperties(const std::string& properties) { m_properties = properties; }
+  void setCreated(const QDateTime& created) { m_created = created; }
+  void setModified(const QDateTime& modified) { m_modified = modified; }
+  void setFileStatus(FileStatus status) { m_fileStatus = status; }
+  void setFileCategory(FileCategory category) { m_fileCategory = category; }
+  void setFileType(FileType type) { m_fileType = type; }
+  void setTemplate(bool isTemplate) { m_isTemplate = isTemplate; }
+  void setHidden(bool hidden) { m_hidden = hidden; }
+  void setUsedBy(bool used) { m_used = used; }
+  void setUsedBy(const std::string& usedBy) { m_usedBy = usedBy; m_used = !usedBy.empty(); }
+  void setMainFolder(MainFolder mainFolder) { m_mainFolder = mainFolder; }
+  
+  // Utility
+  bool isValid() const { return m_id > 0; }
+  
+private:
+  int32_t m_id;
+  int32_t m_fileId;
+  int32_t m_folderId;
+  int32_t m_operatorId;
+  std::optional<int32_t> m_exerciseId;
+  std::optional<int32_t> m_phaseId;
+  QString m_fileName;
+  QString m_mimeType;
+  int64_t m_size;
+  QByteArray m_content;
+  std::string m_properties;
+  QDateTime m_created;
+  QDateTime m_modified;
+  FileStatus m_fileStatus;
+  FileCategory m_fileCategory;
+  FileType m_fileType;
+  bool m_isTemplate;
+  MainFolder m_mainFolder;
+  bool m_hidden;
+  bool m_used;
+  std::string m_usedBy;
+};
+
+} // namespace FileManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_db_impl.h

@@ -0,0 +1,104 @@
+/**
+  * @RDE_HEADER@
+  * Stub header for CODEGEN_DATABASE generated code (BUILD_RTI=OFF)
+  * This file is generated by CODEGEN_DATABASE macro when BUILD_RTI=ON
+  * For BUILD_RTI=OFF builds, this stub provides the minimal interface
+  */
+#pragma once
+
+#include <QString>
+#include <FileManagement/flm_db.h>
+#include <ngldb/nsqlquery.h>
+
+// Minimal Logger stub for BUILD_RTI=OFF
+namespace NGL
+{
+enum class LogLevel
+{
+  Undefined = 0,
+  Trace     = 64,
+  Debug     = 96,
+  Info      = 128,
+  Warning   = 150,
+  Error     = 182,
+  Fatal     = 214,
+};
+
+class Logger
+{
+public:
+  bool isTraceEnabled() const { return false; }
+  bool isDebugEnabled() const { return true; }
+  bool isInfoEnabled() const { return true; }
+  bool isWarningEnabled() const { return true; }
+  bool isErrorEnabled() const { return true; }
+  bool isFatalEnabled() const { return true; }
+};
+}
+
+// Logger macros (simplified for Qt6) - work with pointer
+#define LOGFUNCTION Q_FUNC_INFO
+
+#ifdef LTS_DEBUG
+#define TRACE_LOG(logger) \
+  for (bool log_level_enabled = (logger)->isDebugEnabled(); log_level_enabled; log_level_enabled = false) \
+    qDebug() << "[TRACE]" << __FILE__ << ":" << __LINE__ << Q_FUNC_INFO
+#else
+#define TRACE_LOG(logger) \
+  if (false) qDebug()
+#endif
+
+#define DEBUG_LOG(logger) \
+  if (!(logger)->isDebugEnabled()) {} else qDebug() << "[DEBUG]" << __FILE__ << ":" << __LINE__ << Q_FUNC_INFO
+
+#define INFO_LOG(logger) \
+  if (!(logger)->isInfoEnabled()) {} else qDebug() << "[INFO]" << __FILE__ << ":" << __LINE__ << Q_FUNC_INFO
+
+#define WARNING_LOG(logger) \
+  if (!(logger)->isWarningEnabled()) {} else qWarning() << "[WARNING]" << __FILE__ << ":" << __LINE__ << Q_FUNC_INFO
+
+#define ERROR_LOG(logger) \
+  if (!(logger)->isErrorEnabled()) {} else qCritical() << "[ERROR]" << __FILE__ << ":" << __LINE__ << Q_FUNC_INFO
+
+#define FATAL_LOG(logger) \
+  if (!(logger)->isFatalEnabled()) {} else qCritical() << "[FATAL]" << __FILE__ << ":" << __LINE__ << Q_FUNC_INFO
+
+namespace FileManagement
+{
+
+/**
+ * @brief Base class for database interface implementation
+ * 
+ * This class is normally generated by CODEGEN_DATABASE macro.
+ * This stub provides minimal interface for BUILD_RTI=OFF builds.
+ */
+class DatabaseInterfaceImpl
+{
+public:
+  DatabaseInterfaceImpl()
+    : m_logger(nullptr)
+    , m_query(nullptr)
+  {
+    m_logger = new NGL::Logger();
+    m_query = new NSqlQuery(QSqlDatabase());
+  }
+  virtual ~DatabaseInterfaceImpl()
+  {
+    delete m_logger;
+    delete m_query;
+  }
+
+  // Virtual methods that can be overridden by custom implementations
+  virtual bool updateStatus(int fileId, const FileStatus &status, int operatorId) = 0;
+  virtual bool setUsedBy(int fileId, const bool &usedBy, int usedNo, int operatorId) = 0;
+
+protected:
+  // Member variables expected by custom implementations
+  NGL::Logger* m_logger;
+  NSqlQuery* m_query;
+
+  // Helper methods expected by custom implementations
+  QString getTableName(const QString &baseName) const { return baseName; }
+};
+
+} // namespace FileManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/FileManagement/flm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_dtc_impl.h

@@ -0,0 +1,86 @@
+/**
+  * @RDE_HEADER@
+  * FileManagement DTC Implementation
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Stub-Header für Qt6-Migration - ersetzt DDS-generierten Header
+  */
+#pragma once
+
+#include <FileManagement/flm_db_impl.h>
+#include <DDS/DTC/generic_dtc.h>
+#include <memory>
+
+// Forward declarations für DDS
+namespace DDSConnector
+{
+class DdsConnector;
+}
+
+// Stub für DDS DataReader - wird normalerweise von DDS generiert
+template<typename T>
+class DdsDataReaderStub
+{
+public:
+  struct LoanedSamplesWrapper
+  {
+    auto begin() { return m_samples.begin(); }
+    auto end() { return m_samples.end(); }
+    std::vector<T> m_samples;
+  };
+  
+  LoanedSamplesWrapper readAlive() { return LoanedSamplesWrapper{}; }
+};
+
+//-------------------------------------------------------------------------------------------------------------
+namespace FileManagement
+{
+namespace Interface
+{
+/**
+ * @brief DtcImpl - Basisklasse für FileManagement DTC
+ * 
+ * Stellt Logger und DDS-DataReader für Custom-Implementierungen bereit
+ * Erbt von DatabaseInterfaceImpl für Datenbank-Zugriff
+ */
+class DtcImpl : public DatabaseInterfaceImpl
+{
+public:
+  explicit DtcImpl(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
+    : DatabaseInterfaceImpl()
+    , m_ddsConnector(ddsConnector)
+    , m_dtcFileContent(std::make_unique<DdsDataReaderStub<FileContent>>())
+    , m_dtcFolder(std::make_unique<DdsDataReaderStub<Folder>>())
+  {
+    // Logger wird von DatabaseInterfaceImpl bereitgestellt
+    // m_logger ist in DatabaseInterfaceImpl definiert
+  }
+
+  ~DtcImpl() override = default;
+
+  // Virtuelle Methoden für Custom-Implementierung
+  virtual bool getAllTemplates(QList<FileContent> &allTemplates) = 0;
+  virtual bool getAllFiles(const FileType &fileType, int folderId, QStringList &allFiles, bool showHidden = false) = 0;
+  virtual bool getFilesOperator(const FileType &fileType, int folderId, int operatorId, QStringList &allFiles) = 0;
+  virtual bool getFile(const FileType &fileType, int folderId, const QString &fileName, FileContent &fileMetadata) = 0;
+  virtual int getExerciseId(int folderId) = 0;
+  virtual int getFileId(const FileType &fileType, const QString &fileName, int exerciseId, int phaseId) = 0;
+  virtual int findFolder(int parentId, const QString &name) const = 0;
+  virtual int getExerciseFolderId(int exerciseId) const = 0;
+  virtual int getPhaseFolderId(int exerciseId, int phaseId) const = 0;
+  virtual int getPartyFolderId(int exerciseId, int partyId) const = 0;
+
+  // Default-Implementierungen für Namen-Helper
+  virtual QString getExerciseFolderName(int exerciseId) const { return QLatin1String("$EX_") + QString::number(exerciseId); }
+  virtual QString getPartyFolderName(int partyId) const { return QLatin1String("$PY_") + QString::number(partyId); }
+  virtual QString getPhaseFolderName(int phaseId) const { return QLatin1String("$PH_") + QString::number(phaseId); }
+
+protected:
+  std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnector;
+  std::unique_ptr<DdsDataReaderStub<FileContent>> m_dtcFileContent;
+  std::unique_ptr<DdsDataReaderStub<Folder>> m_dtcFolder;
+};
+
+} // namespace Interface
+} // namespace FileManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_enums.hpp.stub

@@ -0,0 +1,39 @@
+// Stub file for flm_enums.hpp - used when BUILD_RTI=OFF
+#ifndef FLM_ENUMS_HPP
+#define FLM_ENUMS_HPP
+
+#include <cstdint>
+
+namespace FileManagement {
+
+enum class FileType : std::int32_t {
+    Unknown = 0,
+    Document = 1,
+    Image = 2,
+    Video = 3,
+    Audio = 4
+};
+
+enum class FileStatus : std::int32_t {
+    Available = 0,
+    Downloading = 1,
+    Error = 2,
+    Valid = 3,
+    Deleted = 4
+};
+
+enum class MainFolder : std::int32_t {
+    None = 0,
+    Global = 1,
+    Local = 2
+};
+
+enum class FileCategory : std::int32_t {
+    Global = 0,
+    Local = 1,
+    Personal = 2
+};
+
+} // namespace FileManagement
+
+#endif // FLM_ENUMS_HPP

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_ftc.h

@@ -0,0 +1,20 @@
+/**
+  * @RDE_HEADER@
+  * FileManagement Topic Client Stub (BUILD_RTI=OFF)
+  * Normally generated from flm_service.xml by DDS Code Generator
+  */
+
+#pragma once
+
+#include <memory>
+
+namespace FileManagement
+{
+namespace Interface
+{
+
+// Forward declaration - actual implementation provided by DDS when BUILD_RTI=ON
+class Ftc;
+
+} // namespace Interface
+} // namespace FileManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FileManagement/flm_translation.h

@@ -0,0 +1,73 @@
+/**
+ * @RDE_HEADER@
+ * Convert DSS enumerations to translatable strings
+ * $Id$
+ * $HeadURL$
+ * $Author$
+ */
+
+#pragma once
+
+// filename: flm_translation.h
+
+#include "flm_enums.hpp"
+#include <QString>
+
+namespace FileManagement
+{
+// Translatable enumerations:
+inline QString toString(FileType state)
+{
+    switch (state) {
+        case FileType::Unknown: return QStringLiteral("Unknown");
+        case FileType::Text: return QStringLiteral("Text");
+        case FileType::Xml: return QStringLiteral("XML");
+        case FileType::Pdf: return QStringLiteral("PDF");
+        case FileType::Jpg: return QStringLiteral("Image");
+        case FileType::Png: return QStringLiteral("Image");
+        case FileType::Gif: return QStringLiteral("Image");
+        case FileType::Bmp: return QStringLiteral("Image");
+        case FileType::Tiff: return QStringLiteral("Image");
+        case FileType::Video: return QStringLiteral("Video");
+        case FileType::Audio: return QStringLiteral("Audio");
+        case FileType::MSOfficeDocument:
+        case FileType::MSOfficeDocument97:
+        case FileType::OpenOfficeDocument:
+        case FileType::Doc:
+        case FileType::Odt:
+        case FileType::Ods:
+        case FileType::Odp:
+            return QStringLiteral("Document");
+        case FileType::TacticalPlan: return QStringLiteral("TacticalPlan");
+        case FileType::OperatorFavourite: return QStringLiteral("OperatorFavourite");
+        case FileType::OperatorDefinedSymbol: return QStringLiteral("OperatorDefinedSymbol");
+        default: return QStringLiteral("Unknown");
+    }
+}
+
+inline QString toString(FileCategory state)
+{
+    switch (state) {
+        case FileCategory::Global: return QStringLiteral("Global");
+        case FileCategory::Exercise: return QStringLiteral("Exercise");
+        case FileCategory::User: return QStringLiteral("User");
+        default: return QStringLiteral("Unknown");
+    }
+}
+
+inline QString toString(FileStatus state)
+{
+    switch (state) {
+        case FileStatus::Valid: return QStringLiteral("Valid");
+        case FileStatus::Deleted: return QStringLiteral("Deleted");
+        default: return QStringLiteral("Unknown");
+    }
+}
+
+// Translatable struct members:
+inline QString trFolderName(const QString &text)
+{
+    return text;
+}
+
+} // namespace FileManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FilterManagement/flt_dts.cpp

@@ -0,0 +1,72 @@
+/**
+ * DDS Stub Implementation for FilterManagement DTS/FTS
+ * 
+ * This is a minimal stub implementation to enable building without
+ * the actual DDS-generated code.
+ */
+
+#include "flt_dts.h"
+#include "flt_fts.h"
+#include <Core/core_types.h>
+
+namespace FilterManagement
+{
+namespace Interface
+{
+
+// Dts Stub Implementation
+class DtsImpl : public Dts
+{
+public:
+  explicit DtsImpl(const std::shared_ptr<DDSConnector::DdsConnector> & /*connector*/)
+  {}
+  
+  bool enableAll() override
+  {
+    // Stub - always succeeds
+    return true;
+  }
+  
+  void publish(const AesFilter & /*filter*/) override
+  {
+    // Stub - no-op
+  }
+  
+  void removeAesFilterByKey(int /*key*/) override
+  {
+    // Stub - no-op
+  }
+};
+
+std::shared_ptr<Dts> Dts::create(const std::shared_ptr<DDSConnector::DdsConnector> &connector)
+{
+  return std::make_shared<DtsImpl>(connector);
+}
+
+// Fts Stub Implementation
+class FtsImpl : public Fts
+{
+public:
+  explicit FtsImpl(const std::shared_ptr<DDSConnector::DdsConnector> & /*connector*/)
+  {}
+  
+  bool enableAll() override
+  {
+    // Stub - always succeeds
+    return true;
+  }
+  
+  void aesFilterUpdateReply(const rti::core::SampleIdentity & /*cookie*/,
+                            const Core::FunctionReplyObject & /*reply*/) override
+  {
+    // Stub - no-op
+  }
+};
+
+std::shared_ptr<Fts> Fts::create(const std::shared_ptr<DDSConnector::DdsConnector> &connector)
+{
+  return std::make_shared<FtsImpl>(connector);
+}
+
+} // namespace Interface
+} // namespace FilterManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FilterManagement/flt_dts.h

@@ -0,0 +1,67 @@
+/**
+ * DDS Stub Header for FilterManagement DTS (Data Transfer Service)
+ * 
+ * This is a minimal stub header to enable building without the actual
+ * DDS-generated headers. The real flt_dts.h would be generated by RTI DDS
+ * from IDL definitions.
+ */
+
+#pragma once
+
+#include <memory>
+#include <QtCore/QString>
+#include <QtCore/QDateTime>
+#if BUILD_RTI
+#include <rti/core/SampleIdentity.hpp>
+#include <DDS/DDSConnector/dds_connector.h>
+#endif
+
+namespace FilterManagement
+{
+
+// Forward declaration
+class AesFilter;
+
+namespace Interface
+{
+
+/**
+ * @brief Dts - DDS Data Transfer Service interface for FilterManagement
+ * 
+ * Stub implementation - real type would be DDS-generated
+ */
+class Dts
+{
+public:
+  static std::shared_ptr<Dts> create(const std::shared_ptr<DDSConnector::DdsConnector> &connector);
+  
+  virtual ~Dts() = default;
+  
+  virtual bool enableAll() = 0;
+  
+  // AesFilter operations
+  virtual void publish(const AesFilter &filter) = 0;
+  virtual void removeAesFilterByKey(int key) = 0;
+};
+
+/**
+ * @brief Fts - DDS Filter Tasking Service interface for FilterManagement
+ * 
+ * Stub implementation - real type would be DDS-generated
+ */
+class Fts
+{
+public:
+  static std::shared_ptr<Fts> create(const std::shared_ptr<DDSConnector::DdsConnector> &connector);
+  
+  virtual ~Fts() = default;
+  
+  virtual bool enableAll() = 0;
+  
+  // AesFilter operations
+  virtual void aesFilterUpdateReply(const rti::core::SampleIdentity &cookie,
+                                    const Core::FunctionReplyObject &reply) = 0;
+};
+
+} // namespace Interface
+} // namespace FilterManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FilterManagement/flt_ftc.h

@@ -0,0 +1,159 @@
+/**
+ * @file flt_ftc.h
+ * @brief DDS-generated Stub-Header für FilterManagement FTC (Filter Topic Client)
+ * 
+ * Dieser Header ist ein Stub für den von RTI DDS Generator erzeugten Header.
+ * Ermöglicht Build ohne echte DDS-Codegenerierung.
+ */
+
+#pragma once
+
+#include <memory>
+#include <QtCore/QString>
+#include <QtCore/QMap>
+#include <QtCore/QJsonObject>
+#include <Core/core_types.h>
+#include <Core/core_enums.hpp>
+#include <AreaEffectSimulation/aes.hpp>
+
+namespace rti {
+namespace core {
+  class SampleIdentity;
+}
+}
+
+namespace FilterManagement {
+
+// Forward declarations
+class AesFilter
+{
+public:
+  AesFilter() = default;
+  ~AesFilter() = default;
+  
+  // Placeholder members for AesFilter functionality
+  QString getName() const { return m_name; }
+  void setName(const QString &name) { m_name = name; }
+  
+  bool isActive() const { return m_active; }
+  void setActive(bool active) { m_active = active; }
+
+private:
+  QString m_name;
+  bool m_active = false;
+};
+
+/**
+ * @brief SymbolAppearance - DDS-Stub für Symbol Appearance Filter
+ */
+class SymbolAppearance
+{
+public:
+  SymbolAppearance() = default;
+  ~SymbolAppearance() = default;
+  
+  // Placeholder members for SymbolAppearance functionality
+  QString getName() const { return m_name; }
+  void setName(const QString &name) { m_name = name; }
+  
+  // Content getter/setter (wird von symbol_appearance_settings_impl.cpp verwendet)
+  QString content() const { return m_content; }
+  void setContent(const QString &c) { m_content = c; }
+
+private:
+  QString m_name;
+  QString m_content;
+};
+
+/**
+ * @brief BuildingComponentFilter - DDS-Stub für Building Component Filter
+ * 
+ * Minimaler Stub der die im Code verwendeten Methoden bereitstellt.
+ */
+class BuildingComponentFilter
+{
+public:
+  BuildingComponentFilter() = default;
+  BuildingComponentFilter(const BuildingComponentFilter &) = default;
+  BuildingComponentFilter &operator=(const BuildingComponentFilter &) = default;
+  ~BuildingComponentFilter() = default;
+  
+  const std::string& content() const { return m_content; }
+  void content(const std::string &c) { m_content = c; }
+
+private:
+  std::string m_content;
+};
+
+namespace Interface {
+
+/**
+ * @brief FTC (Filter Topic Client) Interface
+ * 
+ * DDS-generierte Klasse für Filter-Client-Operationen.
+ * Diese Stub-Implementation ermöglicht Build ohne DDS.
+ */
+class Ftc
+{
+public:
+  virtual ~Ftc() = default;
+
+  /**
+   * @brief Factory-Methode zur Erstellung einer Ftc-Instanz
+   * @param connector DDS-Connector (wird im Stub ignoriert)
+   * @return Shared Pointer zur Ftc-Instanz (nullptr im Stub)
+   */
+  static std::shared_ptr<Ftc> create(void* /*connector*/)
+  {
+    return nullptr; // Stub returns nullptr - actual implementation requires DDS
+  }
+
+  // Reply-Handler Methoden (DDS Request/Reply Pattern)
+  virtual void aesFilterUpdateReply(const rti::core::SampleIdentity& cookie,
+                                     const Core::FunctionReplyObject& ret) = 0;
+  
+  virtual void symbolAppearanceUpdateReply(const rti::core::SampleIdentity& cookie,
+                                            const Core::FunctionReplyObject& ret) = 0;
+  
+  virtual void buildingComponentFilterUpdateReply(const rti::core::SampleIdentity& cookie,
+                                                   const Core::FunctionReplyObject& ret) = 0;
+
+  // Weitere FTC-Methoden nach Bedarf
+  virtual void enableAll() = 0;
+};
+
+/**
+ * @brief AesFilterUpdateReplyHandler - Callback Interface für AesFilter Updates
+ */
+class AesFilterUpdateReplyHandler
+{
+public:
+  virtual ~AesFilterUpdateReplyHandler() = default;
+  virtual void aesFilterUpdateReply(const rti::core::SampleIdentity& cookie,
+                                     const Core::FunctionReplyObject& ret) = 0;
+};
+
+/**
+ * @brief SymbolAppearanceUpdateReplyHandler - Callback Interface für SymbolAppearance Updates
+ */
+class SymbolAppearanceUpdateReplyHandler
+{
+public:
+  virtual ~SymbolAppearanceUpdateReplyHandler() = default;
+  virtual void symbolAppearanceUpdateReply(const rti::core::SampleIdentity& cookie,
+                                            const Core::FunctionReplyObject& ret) = 0;
+};
+
+/**
+ * @brief BuildingComponentFilterUpdateReplyHandler - Callback Interface für BuildingComponentFilter Updates
+ */
+class BuildingComponentFilterUpdateReplyHandler
+{
+public:
+  virtual ~BuildingComponentFilterUpdateReplyHandler() = default;
+  virtual void buildingComponentFilterUpdateReply(const rti::core::SampleIdentity& cookie,
+                                                   const Core::FunctionReplyObject& ret) = 0;
+};
+
+} // namespace Interface
+} // namespace FilterManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FilterManagement/flt_fts.h

@@ -0,0 +1,86 @@
+/**
+ * DDS Stub Header for FilterManagement FTS (Filter Tasking Service)
+ * 
+ * This is a minimal stub header to enable building without the actual
+ * DDS-generated headers. The real flt_fts.h would be generated by RTI DDS
+ * from IDL definitions.
+ */
+
+#pragma once
+
+#include <QtCore/QString>
+#include <QtCore/QDateTime>
+#if BUILD_RTI
+#include <rti/core/SampleIdentity.hpp>
+#endif
+
+namespace FilterManagement
+{
+
+/**
+ * @brief AesFilter - DDS type for AES filter data
+ * 
+ * Stub implementation - real type would be DDS-generated
+ */
+class AesFilter
+{
+public:
+  AesFilter() = default;
+  AesFilter(int id, int operatorId, qint64 sampleTime, const std::string &content, const std::string &ctx)
+    : m_id(id)
+    , m_operatorId(operatorId)
+    , m_sampleTime(sampleTime)
+    , m_content(content)
+    , m_ctx(ctx)
+  {}
+  
+  // Copy constructor from AesFilter (for DDS compatibility)
+  AesFilter(const AesFilter &other) = default;
+  AesFilter &operator=(const AesFilter &other) = default;
+  
+  // Getters
+  int id() const { return m_id; }
+  int operatorId() const { return m_operatorId; }
+  qint64 sampleTime() const { return m_sampleTime; }
+  const std::string &content() const { return m_content; }
+  const std::string &ctx() const { return m_ctx; }
+  
+  // Setters
+  void id(int id) { m_id = id; }
+  void operatorId(int operatorId) { m_operatorId = operatorId; }
+  void sampleTime(qint64 sampleTime) { m_sampleTime = sampleTime; }
+  void content(const std::string &content) { m_content = content; }
+  void ctx(const std::string &ctx) { m_ctx = ctx; }
+  
+private:
+  int m_id = 0;
+  int m_operatorId = 0;
+  qint64 m_sampleTime = 0;
+  std::string m_content;
+  std::string m_ctx;
+};
+
+} // namespace FilterManagement
+
+namespace Interface
+{
+namespace Fts
+{
+
+/**
+ * @brief AesFilterUpdateRequestHandler - DDS request handler interface
+ * 
+ * Stub implementation - real type would be DDS-generated
+ */
+class AesFilterUpdateRequestHandler
+{
+public:
+  virtual ~AesFilterUpdateRequestHandler() = default;
+  
+protected:
+  virtual void onAesFilterUpdateRequest(const rti::core::SampleIdentity &cookie,
+                                        const FilterManagement::AesFilter &request) = 0;
+};
+
+} // namespace Fts
+} // namespace Interface

qt6-after/qt6-migrated-legatus/.forward-declarations/include/FilterManagement/logger.h

@@ -0,0 +1,26 @@
+/**
+  * @RDE_HEADER@
+  * Logging Stub for FilterManagement
+  * Placeholder for DDS-generated logger
+  */
+
+#pragma once
+
+#include <NGLLogger/INGLLogger.h>
+#include <QtCore/QString>
+
+namespace FilterManagement
+{
+using LOGGER_T = NGL::INGLLogger &;
+
+inline LOGGER_T getLogger(const char *name)
+{
+  (void)name; // Unused in stub
+  return NGL::getMemoryLogger();
+}
+
+inline LOGGER_T getLogger(const QString &loggerName)
+{
+  return getLogger(loggerName.toUtf8().constData());
+}
+} // namespace FilterManagement

qt6-after/qt6-migrated-legatus/.forward-declarations/include/GuezIedManagement/gim_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/GuezIedManagement/gim_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/GuezNasat/gna_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/GuezNasat/gna_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/InfrastructureManagement/ism_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/InfrastructureManagement/ism_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/MarkerManagement/mrk_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/MarkerManagement/mrk_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/Messaging/msg_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Messaging/msg_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/MeteoDataManagement/mdm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/MeteoDataManagement/mdm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/NotificationManagement/nom_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/NotificationManagement/nom_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/OcSituationServer/oss_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/OcSituationServer/oss_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/OperatorManagement/opm_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/OperatorManagement/opm_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ParticipantManagement/ppm.hpp

@@ -2,7 +2,7 @@
 // STUB-HEADER: Diese Datei wird normalerweise von DDS generiert
 // Für die Migration erstellen wir minimale Typ-Definitionen
 
-#include "ppm_enums.hpp"
+#include <ParticipantManagement/ppm_enums.hpp>
 
 #include <QtCore/QObject>
 #include <QtCore/QString>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ParticipantManagement/ppm_types.h

@@ -5,7 +5,7 @@
 
 #include <QtCore/QString>
 #include <ostream>
-#include "ppm_enums.hpp"
+#include <ParticipantManagement/ppm_enums.hpp>
 
 namespace ParticipantManagement
 {
@@ -15,7 +15,7 @@ struct Type
 {
     int id = 0;
     QString name;
-    TypeClass typeClass = TypeClass::Unknown;
+    TypeClass typeClass = TypeClass::eUninitialized;
     // Weitere Felder werden bei Bedarf ergänzt
 };
 

qt6-after/qt6-migrated-legatus/.forward-declarations/include/PresentationManagement/pre_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/PresentationManagement/pre_dtc.h>

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ProjectDataManagement/pdm_enums.hpp

@@ -0,0 +1,8 @@
+// Stub file for pdm_enums.hpp - includes generated file from build directory
+#ifndef PDM_ENUMS_HPP
+#define PDM_ENUMS_HPP
+
+// Include generated enums from build directory
+#include <ProjectDataManagement/pdm_enums.hpp>
+
+#endif // PDM_ENUMS_HPP

qt6-after/qt6-migrated-legatus/.forward-declarations/include/ReportManagement/rep_dtc.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ReportManagement/rep_dtc.h>