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).
Emit record_replay fromQVariant for plain enums; document PPM MOC exclusion
2026-09-27 07:33:29 +02:00 · 2026-09-26 00:49:47 +02:00 · 2026-09-25 20:23:37 +02:00 · 2026-09-24 16:49:49 +02:00 · 2026-09-24 10:51:34 +02:00 · 2026-09-24 10:43:10 +02:00
402 changed files with 13575 additions and 1975 deletions
@@ -1 +1,2 @@
-ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJ6kKREEjPzWMq8zjhIUCeiPI1MtwVHiZHaKxkePmW4t berrux.kana@axilinx.com
+torsten.wierschin@life-maps.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIMV8yH39fMOQE5BeCsxI8RMUXbDBJvRuS5phTTfrXF0H
+berrux.kana@axilinx.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJ6kKREEjPzWMq8zjhIUCeiPI1MtwVHiZHaKxkePmW4t berrux.kana@axilinx.com
@@ -0,0 +1,22 @@
+/**
+  * Export definitions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hanna E. Rathje, SLSE, 2015-08-04
+  */
+#pragma once
+
+#include <QtCore/qglobal.h>
+
+#ifndef SAATELEGRAMS_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define SAATELEGRAMS_EXPORT
+# else
+#  if defined(MAKE_SAATELEGRAMS_LIB)
+#   define SAATELEGRAMS_EXPORT Q_DECL_EXPORT
+#  else
+#   define SAATELEGRAMS_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif
@@ -0,0 +1,104 @@
+/**
+ * @RDE_HEADER@
+ * AesHandler for AdlerJson Plugin
+ * $Id: aes_handler.h 62304 2024-03-21 08:17:45Z ewert_j $
+ * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/aes_handler.h $
+ * $Author: ewert_j $
+ * Created by Julius Ewert, ESIM, 2024-03-20
+ */
+
+#pragma once
+
+#include "Core/core_types.h"
+#include "logger.h"
+#include "main_dispatcher.h"
+#include "telegrams.h"
+#include <QtCore/QDateTime>
+#include <QtCore/QHash>
+#include <QtCore/QObject>
+#include <QtCore/QUrl>
+#include <AreaEffectSimulation/aes_dtc.h>
+#include <AreaEffectSimulation/aes_ftc.h>
+#include <LtsUtils/LtsUtilsCore/data_modification_enum.h>
+#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
+#include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm.hpp>
+
+namespace AdlerJson
+{
+
+class MainDispatcher;
+class AesHandler
+    : public QObject
+    , protected AreaEffectSimulation::Interface::Ftc::AirSupportImpactModifyReplyHandler
+    , protected AreaEffectSimulation::Interface::Ftc::OffRouteMineModifyReplyHandler
+    , protected AreaEffectSimulation::Interface::Ftc::EffectClusterModifyReplyHandler
+    , protected AreaEffectSimulation::Interface::Ftc::TrajectoryAdlerModifyReplyHandler
+    , protected NotificationManagement::Interface::Ftc::CreateNotificationReplyHandler
+{
+  Q_OBJECT
+  public:
+  explicit AesHandler(std::shared_ptr<TrainingAreaBase::Interface::Fts> ftsTab, QObject *parent = nullptr);
+
+  bool init(MainDispatcher *mainDispatcher);
+  bool sendAesModifyRequest(const QJsonObject &obj);
+  bool sendExplosionArea(const QJsonObject &data);
+  // DDS Overrides
+  void onAirSupportImpactModifyReply(const Core::FunctionReplyObject &reply) override;
+  void onOffRouteMineModifyReply(const Core::FunctionReplyObject &replyObject) override;
+  void onEffectClusterModifyReply(const Core::FunctionReplyObject &replyObject) override;
+  void onCreateNotificationReply(const Core::FunctionReplyObject &replyObject) override;
+
+  // Internal
+  void onExplosionSingleChanged(const AreaEffectSimulation::ExplosionSingle &data, DataModification modType);
+  void onEffectClusterChanged(const AreaEffectSimulation::EffectCluster &data, DataModification modType);
+
+  void handleCreateSingleExplosion(const TrainingAreaBase::TetraIcd::CreateSingleExplosion &data);
+  void handleEXFire(const Feuerkampfdaten &data, int wsId);
+  void handleEXDontFire(const Feuerkampfdaten &data, int wsId);
+  // Reald Data
+  void sendTrajectoryAdlerModifyRequest(const WirkfeldplanungData &data, int participantId, int wirkmittelIndex, int aesId);
+  void handleEffectCluster(const WirkfeldplanungData &data, int wsId);
+
+  //
+  void removeAllPendingEffectCluster(int partyId);
+  std::shared_ptr<AreaEffectSimulation::Interface::Dtc> getDtc() { return m_dtcAes; };
+  std::shared_ptr<AreaEffectSimulation::Interface::Ftc> getFtc() { return m_ftcAes; };
+
+  private:
+  AreaEffectSimulation::Area createMinimumRect(int zone, const QVector<QPointF> &points);
+
+  signals:
+  void explosionSingleChanged(const QJsonObject &jsonObj);
+
+  private:
+  QList<qint32> findAllPendingEffectCluster(int partyId);
+  void handleAmmoCount(const Feuerkampfdaten &data, int saaPartyId, bool sendExVollzug = false);
+
+  private:
+  MainDispatcher *m_mainDispatcher;
+  std::shared_ptr<AreaEffectSimulation::Interface::Ftc> m_ftcAes;
+  std::shared_ptr<AreaEffectSimulation::Interface::Dtc> m_dtcAes;
+  std::shared_ptr<ParticipantManagement::Interface::Dtc> m_dtcPpm;
+  std::shared_ptr<TrainingAreaBase::DdsHandler> m_ddsHandler;
+
+  void onTrajectoryAdlerModifyReply(const Core::FunctionReplyObject &reply) override;
+
+  LtsUtils::RequestHelper *m_requestHelper;
+
+  QHash<int, AreaEffectSimulation::AesEffectState> m_singleExplosions;
+
+  WirkfeldplanungData m_wirkfeldPlanungsData;
+  QHash<int, QString> m_aesIdToFeuerkampfReferenz; // key = aesId, value = feuerkampfReferenz
+
+  QHash<QString, int> m_feuerkampReferenzAmmoCounter;                                                // key = feuerkampfReferenz, value = AmmoCounter
+  QHash<QString, std::vector<ProjectDataManagement::L27_EffectorId>> m_feuerkampfReferenzWirkmittel; // key = feuerkampfReferenz, value = Kenner
+  QHash<QString, bool> m_feuerkampfReferenzUsedFeuerHalt; // key = feuerkampfReferenz, value = boolean -> if Feuerhalt was activ
+
+  int m_participantId;
+  int m_wirkmittelIndex;
+  int m_aesId;
+  QHash<int, int> aesIdWsId; // key = aesId value = wsId
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,50 @@
+/**
+  * @RDE_HEADER@
+  * $Id: $
+  * $HeadURL: $
+  * $Author:  $
+  * Created by Steve K., ESZS 12-01-2026
+  */
+
+#pragma once
+
+#include "logger.h"
+#include <AssetManagement/asm_dtc.h>
+#include <AssetManagement/asm_ftc.h>
+#include "main_dispatcher.h"
+#include <QtCore/QObject>
+
+namespace AssetManagement
+{
+  namespace Interface
+  {
+    class Dtc;
+    class Ftc;
+  }
+}
+
+namespace AdlerJson
+{
+
+class MainDispatcher;
+class AsmHandler : public QObject
+    , protected AssetManagement::Interface::Ftc::AssetModifyReplyHandler
+{
+  Q_OBJECT
+public:
+  explicit AsmHandler(QObject *parent = nullptr);
+  bool init(MainDispatcher* mainDispatcher);
+
+  std::shared_ptr<AssetManagement::Interface::Dtc> getDtc() { return m_dtcAsm; }
+  std::shared_ptr<AssetManagement::Interface::Ftc> getFtc() { return m_ftcAsm; }
+  void modifyAssetAdlerProperties(int assetId, bool isSaaConnected = false);
+private:
+  void onAssetModifyReply(const Core::FunctionReplyObject &reply) override;
+
+private:
+  std::shared_ptr<AssetManagement::Interface::Dtc> m_dtcAsm;
+  std::shared_ptr<AssetManagement::Interface::Ftc> m_ftcAsm;
+  int m_exerciseId;
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,67 @@
+/**
+ * @RDE_HEADER@
+ * FlmHandler for UFomHlaJson Plugin
+ * $Id: pdm_handler.h 62304 2024-03-21 08:17:45Z ewert_j $
+ * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/UFomHlaJson/pdm_handler.h $
+ * $Author: ewert_j $
+ * Created by Julius Ewert, ESIM, 2024-03-20
+ */
+
+#pragma once
+
+#include "logger.h"
+#include <QtCore/QObject>
+#include <Lts/Services/FileManagement/flm_ftc.h>
+#include <NotificationManagement/nom_ftc.h>
+#include <NotificationManagement/nom_ftc_types.h>
+#include <OperatorManagement/opm_data_plugin_interface.h>
+#include <TrainingAreaBase/dds_handler.h>
+
+namespace FileManagement
+{
+namespace Interface
+{
+class Dtc;
+}
+} // namespace FileManagement
+
+namespace AdlerJson
+{
+
+class MainDispatcher;
+class FlmHandler
+    : public QObject
+    , protected FileManagement::Interface::Ftc::FileContentModifyReplyHandler
+    , protected FileManagement::Interface::Ftc::PathCreateReplyHandler
+    , protected NotificationManagement::Interface::Ftc::CreateNotificationReplyHandler
+{
+  Q_OBJECT
+  public:
+  explicit FlmHandler(QObject *parent = nullptr);
+
+  bool processHQMessage(int partyId, const QString &name, int meldungsnummer, const QJsonObject &obj);
+  void createHQNotification(const int partyId, const int folderId, const int fileId);
+  signals:
+  public slots:
+  bool init(MainDispatcher *mainDispatcher);
+  void initHQFolders(int partyId);
+
+  private:
+  void onFileContentModifyReply(const Core::FunctionReplyObject &reply) override;
+  void onPathCreateReply(const Core::FunctionReplyObject &reply) override;
+  void onCreateNotificationReply(const Core::FunctionReplyObject &replyObject) override final;
+  bool parseContent(const QString &contentString, QMap<QString, QString> &retMap);
+
+  private:
+  MainDispatcher *m_mainDispatcher = nullptr;
+  int m_exerciseId;
+  int m_parentFolderId;
+  int m_partyId;
+  int m_folderHXMessagesId;
+  std::shared_ptr<FileManagement::Interface::Dtc> m_dtcFlm;
+  std::shared_ptr<FileManagement::Interface::Ftc> m_ftcFlm;
+  std::shared_ptr<NotificationManagement::Interface::Ftc> m_ftcNom;
+  std::shared_ptr<OperatorManagement::Interface::Dtc> m_opmDtc;
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "telegrams.h"
+
+class GenerateTelegrams
+{
+  public:
+  GenerateTelegrams();
+
+  static void SAATELEGRAMS_EXPORT addHeaderData(AdlerJson::EXTelegramBase &tele, const int saaId, const QString referenceUuid = QString{});
+  static void SAATELEGRAMS_EXPORT generateConnectResponseMessage(AdlerJson::ExAnmeldebestaetigung &exAnmeldebestaetigung);
+  static void SAATELEGRAMS_EXPORT generateConnectMessage(AdlerJson::EXRegistration &exRegistration, int partyId, bool isVerbund = true);
+  static void SAATELEGRAMS_EXPORT generateDisconnectMessage(AdlerJson::EXDeregistration &eXDeregistration, int partyId);
+  static void SAATELEGRAMS_EXPORT generateStatusMessage(AdlerJson::EXStatus &exStatus, AdlerJson::Szenarstatus status);
+  static void SAATELEGRAMS_EXPORT generateConnectionTestMessage();
+  static void SAATELEGRAMS_EXPORT generateAbmeldung(AdlerJson::EXDeregistration &req);
+  static void SAATELEGRAMS_EXPORT generateZeit1(AdlerJson::Zeitangabe_DTG &zeit);
+  static void SAATELEGRAMS_EXPORT generateZeit2(AdlerJson::Zeitangabe_DTG &zeit);
+
+  // fire
+  static void SAATELEGRAMS_EXPORT generateZieldaten(AdlerJson::Zieldaten &wzd);
+  static void SAATELEGRAMS_EXPORT generateWirkmittelFeuerkommando_Gmlrs(QVector<AdlerJson::WirkmittelFeuerkommandoRakete> &wfr);
+  static void SAATELEGRAMS_EXPORT generateEXFQBABBFK(AdlerJson::ExAwesPlanning &req);
+  static void SAATELEGRAMS_EXPORT generateEXFQBABBFK_Gmlrs(AdlerJson::ExAwesPlanning &req);
+  static void SAATELEGRAMS_EXPORT generateEXFQBABBFK_Dm72(AdlerJson::ExAwesPlanning &req);
+  static void SAATELEGRAMS_EXPORT generateFeuerbereit(AdlerJson::ExFeuerbereit &req);
+  static void SAATELEGRAMS_EXPORT generateFeuern(AdlerJson::ExFeuern &req);
+  static void SAATELEGRAMS_EXPORT generateFeuern_Gmlrs(AdlerJson::ExFeuern &req);
+  static void SAATELEGRAMS_EXPORT generateFeuern_Dm72(AdlerJson::ExFeuern &req);
+  static void SAATELEGRAMS_EXPORT generateNichtFeuern(AdlerJson::exNichtFeuern &req);
+
+  static void SAATELEGRAMS_EXPORT generateAbgefeuert(AdlerJson::ExAbgefeuert &req);
+  static void SAATELEGRAMS_EXPORT generateVollzugsmeldung(AdlerJson::ExVollzugsmeldung &req);
+  // static void SAATELEGRAMS_EXPORT generateErkundungsanfrage(AdlerJson::ExErkundungsanfrage &req);
+  static void SAATELEGRAMS_EXPORT generateErkundungsergebnisse(AdlerJson::ExErkundungsergebnisse &req);
+  static void SAATELEGRAMS_EXPORT generateFeuerkampf(AdlerJson::ExFeuerkampf &req);
+  static void SAATELEGRAMS_EXPORT generateFeuerhalt(AdlerJson::ExFeuerhalt &req);
+  static void SAATELEGRAMS_EXPORT generateStellungsmeldungFS(AdlerJson::ExFeuerstellungFS &req);
+  static void SAATELEGRAMS_EXPORT generateStellungsmeldungWS(AdlerJson::ExFeuerstellungWS &req);
+  static void SAATELEGRAMS_EXPORT generateStellungsmeldungWS_Gmlrs(AdlerJson::ExFeuerstellungWS &req);
+  static void SAATELEGRAMS_EXPORT generateStellungsmeldungWS_Dm72(AdlerJson::ExFeuerstellungWS &req);
+  static void SAATELEGRAMS_EXPORT generateStellungsmeldungLP(AdlerJson::ExFeuerstellungLP &req);
+  static void SAATELEGRAMS_EXPORT generateStellungswechsel(AdlerJson::ExStellungswechsel &req);
+  static void SAATELEGRAMS_EXPORT generateKoordinierungsmassnahmen(AdlerJson::ExHqKoordinierungsmassnahmen &req);
+  static void SAATELEGRAMS_EXPORT generateKoordinierungsmassnahmen_EX_L25(AdlerJson::ExHqKoordinierungsmassnahmen &req,
+                                                                          ProjectDataManagement::L25_KindGuidingLine kind, int i);
+  static void SAATELEGRAMS_EXPORT generateFuehrungslinien(AdlerJson::ExHqFuehrungslinien &req);
+  static void SAATELEGRAMS_EXPORT generateFuehrungslinien_EX_L24(AdlerJson::ExHqFuehrungslinien &req, AdlerJson::Art_L24 art24, int meldungsnummer);
+  static void SAATELEGRAMS_EXPORT generateTechnischeQuittung(AdlerJson::ExTqTechnischeQuittung &req);
+  static void SAATELEGRAMS_EXPORT generateFreitextmeldung(AdlerJson::ExAqFreitextmeldung &req);
+  static void SAATELEGRAMS_EXPORT generateManuelleQuittung(AdlerJson::ExMqManuelleQuittung &req);
+  static void SAATELEGRAMS_EXPORT generateFlugbahnberechnung(AdlerJson::ExFlugbahnberechnung &req);
+  static void SAATELEGRAMS_EXPORT generateFlugbahndaten(AdlerJson::ExFlugbahndaten &req);
+};
@@ -0,0 +1,15 @@
+#pragma once
+
+class InterfaceController
+{
+public:
+  InterfaceController();
+
+public Q_SLOTS:
+  void onRegistration();
+  void onDeregistration();
+
+  void onNewConnection();
+  void onWebSocketDisconnected();
+  void onTextMessageReceived(const QByteArray &baJson);
+};
@@ -0,0 +1,158 @@
+/**
+ * @RDE_HEADER@
+ * HlaDispatcher for AdlerJson Plugin
+ * $Id: hla_dispatcher.h 62304 2024-03-21 08:17:45Z ewert_j $
+ * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/hla_dispatcher.h $
+ * $Author: ewert_j $
+ * Created by Julius Ewert, ESIM, 2024-03-20
+ */
+
+#pragma once
+
+#include <QtCore/QHash>
+#include <QtCore/QObject>
+#include <QtCore/QVector>
+#include <QtWebSockets/QWebSocket>
+#include <Core/core_types.h> // tr_lts
+#include <TrainingAreaBase/tab_plugin_interface.h>
+// #include "logger.h"
+#include "aes_handler.h"
+#include "asm_handler.h"
+#include "flm_handler.h"
+#include "pdm_handler.h"
+#include "ppm_handler.h"
+#include "saa_interface.h"
+#include "telegrams.h"
+#include "ws_interface.h"
+
+// #include <NotificationManagement/nom_ftc.h>
+#include <NotificationManagement/nom_enums.hpp>
+// #include <TrainingAreaBase/tab_dts.h>
+// #include <TrainingAreaBase/tab_fts.h>
+
+class QTimer;
+namespace AdlerJson
+{
+using namespace TrainingAreaBase;
+class JsonHandlerRx;
+class JsonHandlerTx;
+class DdsHandler;
+// class EXStatus;
+
+struct TrajectoryIdentifier
+{
+  int aesItemId;
+  int explosionId;
+};
+
+class JsonDispatcher final
+    : public TrainingAreaBase::Plugin::Interface
+    , protected TrainingAreaBase::Interface::Fts::AdlerCalculateTrajectoryRequestHandler
+    , protected NotificationManagement::Interface::Ftc::CreateNotificationReplyHandler
+{
+  Q_OBJECT
+  public:
+  JsonDispatcher(TrainingAreaBase::Plugin::DataProvider *pdp,
+                 const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                 const std::shared_ptr<TrainingAreaBase::TxMixin> &sendToTabCb,
+                 NGL::Settings *settings,
+                 std::shared_ptr<TrainingAreaBase::DdsHandler> &ddsHandler,
+                 std::shared_ptr<FlmHandler> &flmHandler,
+                 MainDispatcher *mainDispatcher);
+
+  public Q_SLOTS:
+  bool init() override;
+
+  public:
+  std::shared_ptr<TrainingAreaBase::SendToTab> sendToTab() override;
+  bool isDebugInterface() const override { return false; }
+  bool canSendData() const override;
+  void exerciseChanged() override { return; }
+  const char *name() const override { return tr_lts("dds", "APHLA"); }
+  std::shared_ptr<SAAInterface> getSAAByParty(const int partyId);
+  std::shared_ptr<SAAInterface> getSAAByWs(const int wsId);
+  QString getSender() { return QStringLiteral("EXCON@GUEZ.DE"); }
+  // SendToTele
+  bool sendExFeuerbereit(const ExFeuerbereit &exFBDataIn, const int partyId);
+  bool sendExAbgefeuert(const ExAbgefeuert &exAFDataIn, int partyId);
+  bool sendExMqManuelleQuittung(const ExMqManuelleQuittung &exMQDataIn, int partyId);
+  bool sendExTqTechnischeQuittung(const ExTqTechnischeQuittung &exTQDataIn, int partyId);
+  bool sendExVollzugsmeldung(const ExVollzugsmeldung &exVZDataIn, int partyId);
+  void onAdlerCalculateTrajectoryRequest(const rti::core::SampleIdentity &cookie, const TrainingAreaBase::AdlerCalculateTrajectoryRequest &request) override;
+  int getAssetId(const QString &saaName) const;
+  // misc
+  void cleanupSaaInterfaces(const QString &saaName, int wsId, int partyId);
+  void getCreateNotificationRequestData(const int wsId,
+                                        const QString &title,
+                                        NotificationManagement::CreateNotification &data,
+                                        const QString &content = {},
+                                        const QStringList &contentArgs = {});
+  void createNotificationRequest(const int wsId, const QString &title, const NotificationManagement::MessageType messageType, const NotificationManagement::NotificationType notificationType, const QString &content = {}, const QStringList &contentArgs = {});
+
+  public Q_SLOTS:
+  void onSAARegistration(const int wsId, const int partyId, const QString &saaName, const QString &szenarName, bool isVerbund, const QString &uuid);
+  void onSAADeregistration(const int wsId, const int partyId);
+  void onSAAConnectionTest(const int wsId, const QString &uuid);
+  void onSAAStatus(const int wsId, const EXStatus &status);
+  void onSAAExceptionStatus(const int wsId, const TechnischeDaten &exceptionStatus);
+  void onSAASQWS(const int wsId, const Waffensystemdaten &exSQWS);
+  void onSAASQFS(const int wsId, const Feuerstellungsdaten &exSQFS);
+  void onSAASQLP(const int wsId, const Ladeplatzdaten &exSQLP);
+  void onSAAHXGuidingLines(const int wsId, const Koordinierungsdaten &koordinierungsdaten);
+  void onSAAHXGuidingLinesAndBoundaries(const int wsId, const Fuehrungsdaten &fuehrungsdaten);
+  void onSSAEXFIREHALT(const int wsId, const FeuerHaltDaten &feuerhaltdaten);
+  void onSAATrajectoryData(const int wsId, const Flugbahndaten &exFlugbahndaten, const QString referenceUuid);
+
+  void onWebSocketConnected();
+  void onNewWebsocketConnected(const int wsId, const QString &address, qint16 port);
+  void onWSDisconnected(const int wsId);
+  void onWebsocketExternalConnectionStateChanged(bool bConnected);
+  void onWebSocketError();
+  void onRecivedTelegram(int wsId, const QJsonObject &telegramData);
+  void onTextMessageReceived(const QByteArray &message);
+  void connectWebsocket();
+  void reallyConnectWebsocket() { connectWebsocket(); }
+
+  void onKeepAliveTimerTimeout();
+  void onCreateNotificationReply(const Core::FunctionReplyObject &replyObject);
+  Q_SIGNALS:
+  void broadcastTelegramsRequest(const int equipmentNumber, const int broadcastIndex, const int resetCounter);
+  void jsonTelegramReceived(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tele);
+  void websocketConnected(quint16 port);
+
+  private:
+  QUrl webSocketUrl() const;
+  bool isConnectionTest(QJsonDocument &doc);
+  QString getParticipantInfoLink(const QString &verein, const int partyId, const bool isVerbund);
+
+  std::shared_ptr<SAAInterface> getSAAByName(const QString &saaName);
+
+  private:
+  std::shared_ptr<TrainingAreaBase::RecvFromTab> m_recvFromTabCb;
+  std::shared_ptr<JsonHandlerRx> m_recvFromWebsocket;
+  std::shared_ptr<JsonHandlerTx> m_sendToWebsocket;
+  // DDS
+  MainDispatcher *m_mainDispatcher;
+  std::shared_ptr<FlmHandler> m_flmHandler;
+  std::shared_ptr<PpmHandler> m_ppmHandler;
+
+  std::shared_ptr<TrainingAreaBase::Interface::Fts> m_ftsTab;
+  std::shared_ptr<TrainingAreaBase::Interface::Dts> m_dtsTab;
+  std::shared_ptr<NotificationManagement::Interface::Ftc> m_ftcNom;
+
+  QVector<std::shared_ptr<SAAInterface>> m_saaInterfaces;
+  QMap<int, QTimer *> m_connectionKeepaliveTimer;
+
+  QHash<QString, TrajectoryIdentifier> m_trajectoryIdentifier; // key = exFlugbahnberechnung.uuid
+  QHash<QString, Core::GeoPosition> m_positionsLaunch;         // key = exFlugbahnberechnung.uuid
+
+  NGL::Settings *m_settings;
+  QWebSocket *m_webSocket;
+  std::shared_ptr<TrainingAreaBase::WebSocketInterface> m_webSocketInterface;
+  QTimer *m_webSocketReconnectTimer;
+  bool m_bWarnedOnce;
+  rti::core::SampleIdentity m_cookieCalculateTrajectoryAdler;
+  int m_explosionIndex;
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,59 @@
+/**
+  * @RDE_HEADER@
+  * JsonHandlerRx for AdlerJson Plugin
+  * $Id: hla_handler_rx.h 62304 2024-03-21 08:17:45Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/hla_handler_rx.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include <TrainingAreaBase/recv_from_tab.h>
+#include <TrainingAreaBase/tx_mixin.h>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+#include <QtCore/QObject>
+#include <QtCore/QString>
+#include <memory>
+#include "logger.h"
+
+namespace AdlerJson
+{
+class AesHandler;
+class PpmHandler;
+class JsonDispatcher;
+class JsonHandlerRx : public QObject
+{
+  Q_OBJECT
+public:
+    explicit JsonHandlerRx(const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                        const std::shared_ptr<TrainingAreaBase::TxMixin>     &sendToTabCb,
+                        JsonDispatcher *dispatcher,
+                        AesHandler    *aesHandler,
+                        PpmHandler    *ppmHandler);
+
+  bool handleTelegram (const QByteArray &baJson                                 );
+  bool handleTelegram (TrainingAreaBase::TetraIcd::TrainingAreaTelegram *tabTele);
+  bool handleTelegram (int wsId, const QJsonObject& telegram, int &errorcode);
+Q_SIGNALS:
+  void participantConnectionState(int equipmentNumber, bool dataCommunicationPossible);
+private:
+  template<typename T>
+  void rxData         (const T &data      );
+
+  template<typename T>
+  void txData         (const T &data      );
+
+  bool checkExercise  (int equipmentNumber) const;
+private:
+  std::shared_ptr<TrainingAreaBase::RecvFromTab> m_rxHandler;
+  std::shared_ptr<TrainingAreaBase::TxMixin>     m_txHandler;
+  JsonDispatcher *m_dispatcher;
+  bool           m_bWarnedOnce;
+  bool           m_bWarnedOnceTx;
+  AesHandler    *m_aesHandler;
+  PpmHandler    *m_ppmHandler;
+  LOGGER_T       m_logger;
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,107 @@
+/**
+  * @RDE_HEADER@
+  * HlaHandlerTx for AdlerJson Plugin
+  * $Id: hla_handler_tx.h 62304 2024-03-21 08:17:45Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/hla_handler_tx.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include "ppm_handler.h"
+#include "pdm_handler.h"
+#include "logger.h"
+//#include "ws_handler.h"
+#include "ws_interface.h"
+#include <TrainingAreaBase/send_to_tab.h>
+#include <TrainingAreaBase/recv_from_tab.h>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+#include <QtCore/QHash>
+
+class QWebSocket;
+class PpmHandler;
+class PdmHandler;
+class AesHandler;
+namespace AdlerJson
+{
+class JsonHandlerTx final : public QObject, public TrainingAreaBase::SendToTab
+{
+  Q_OBJECT
+public:
+  explicit JsonHandlerTx(TrainingAreaBase::Plugin::DataProvider *pdp, MainDispatcher *mainDispatcher);
+
+  void onWebSocketConnected           (QWebSocket *webSocket);
+  void onWebSocketDisconnected        (                     );
+  void onWebsocketConnectedToExternalSystem (bool bConnected      );
+  void setWSInterface(std::shared_ptr<TrainingAreaBase::WebSocketInterface> wsInterface) {m_wsInterface = wsInterface;};
+
+  const char *name      () const override { return "ApAdler"; }
+  void resetSendCounter ()       override;
+
+  HandleState canHandleTelegram (int equipmentNumber, int telegramId) const override;
+
+  bool txData (const TrainingAreaBase::TetraIcd::Acknowledge                         &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DemandBite                          &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::Init                                &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::SetVulnerabilityModel               &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DemandEquipmentConfigurationReport  &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DemandVulnerabilityStateChange      &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::LanguageSelection                   &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::EquipmentMessage                    &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::EquipmentMessageOC                  &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateSingleExplosion               &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateAreaExplosion                 &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateMineArea                      &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::MineAreaSingleMineState             &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateNContamination                &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateCContamination                &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DeactivateEffectSimulation          &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ModifyAreaEffectSimulationName      &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::PauseEffectSimulation               &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ResumeEffectSimulation              &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::MineTriggered                       &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DusMineReactivation                 &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateFunctionalArea                &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CreateDusSingleMine                 &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ExerciseEnvironmentData             &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ExerciseStateData                   &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::OpaquePayloadDataOut                &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ParticipantSwVersionsRequest        &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CesHitInformation                   &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::TechnicalArea                       &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::CesHitRequest                       &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ParticipantMode                     &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DemandParticipantMode               &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ParticipantConfiguration            &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::DemandParticipantConfiguration      &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ExerciseEquipmentAssignmentComplete &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::Sanitation                          &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::SelectiveReammunition               &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::SetDevicePowerRequest               &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::OcCommand                           &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::UAVPerformMission                   &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::UAVChangeState                      &data) override;
+  bool txData (const TrainingAreaBase::TetraIcd::ExFireReadiness &data) override;  
+  bool txData (const TrainingAreaBase::TetraIcd::ExFiredReport&data) override;  
+  bool txData (const TrainingAreaBase::TetraIcd::ExConfirmationReport &data) override;
+
+  QHash<int, bool> dataCommunicationPossible() const;
+public slots:
+  void onParticipantConnectionState (const int equipmentNumber, const bool dataCommunicationPossible);
+  void onGenericTelegram            (const QJsonObject &telegram);
+  void onGenericTelegram1           (const int wsId, const QJsonObject &telegram);
+private:
+  bool sendToTx(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *data, const bool bForce = false);
+private:
+  TrainingAreaBase::Plugin::DataProvider *m_pdp;
+  QHash<int, bool>   m_dataCommunicationPossible; // equioNo, reachable
+  MainDispatcher    *m_mainDispatcher;
+  QWebSocket        *m_webSocket;
+  std::shared_ptr<TrainingAreaBase::WebSocketInterface> m_wsInterface;
+  bool               m_bWebsocketConnectedToExternalSystem;
+  LOGGER_T           m_logger;
+
+};
+
+}// namespace AdlerJson
@@ -0,0 +1,23 @@
+/**
+  * @RDE_HEADER@
+  * Logger for AdlerJson Plugin
+  * $Id: logger.h 62304 2024-03-21 08:17:45Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/logger.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include <NGLLogger/INGLLogger.h>
+
+namespace AdlerJson
+{
+using LOGGER_T = NGL::INGLLogger&;
+
+LOGGER_T getLogger(const char *name);
+inline LOGGER_T getLogger(const QString &loggerName)
+{
+  return getLogger(loggerName.toUtf8().constData());
+}
+} // namespace AdlerJson
@@ -0,0 +1,84 @@
+/**
+  * @RDE_HEADER@
+  * MainDispatcher for AdlerJson Plugin
+  * $Id: main_dispatcher.h 62899 2024-05-29 11:08:50Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/main_dispatcher.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include <QtCore/QObject>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+#include <Core/core_types.h> // tr_lts
+#include <TrainingAreaBase/dds_handler.h>
+//#include "logger.h"
+#include "ppm_handler.h"
+#include "pdm_handler.h"
+#include "aes_handler.h"
+#include "flm_handler.h"
+#include "asm_handler.h"
+
+namespace AdlerJson
+{
+class JsonDispatcher;
+class PpmHandler;
+class PdmHandler;
+class AesHandler;
+class FlmHandler;
+class AsmHandler;
+
+class MainDispatcher final : public TrainingAreaBase::Plugin::Interface
+{
+  Q_OBJECT
+public:
+  MainDispatcher(      TrainingAreaBase::Plugin::DataProvider         *pdp,
+                 const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                 const std::shared_ptr<TrainingAreaBase::TxMixin>     &sendToTabCb,
+                 const std::shared_ptr<TrainingAreaBase::DdsHandler>  &ddsHandler,
+                       NGL::Settings                                  *settings);
+  ~MainDispatcher();
+
+  std::shared_ptr<PpmHandler> ppmHandler() const { return m_ppmHandler; }
+  std::shared_ptr<PdmHandler> pdmHandler() const { return m_pdmHandler; }
+  std::shared_ptr<AesHandler> aesHandler() const { return m_aesHandler; }
+  std::shared_ptr<AsmHandler> asmHandler() const { return m_asmHandler; }
+  JsonDispatcher* jsonDispatcher() const { return m_adlerDispatcher; }
+  std::shared_ptr<TrainingAreaBase::DdsHandler> ddsHandler() const { return m_ddsHandler; }
+
+  int exerciseId() const { return m_exerciseId; }
+
+public slots:
+  bool init() override;
+  void onWebsocketConnected(quint16 port);
+
+public:
+  std::shared_ptr<TrainingAreaBase::SendToTab> sendToTab() override;
+  bool        canSendData      () const override;
+  void        exerciseChanged  ()       override;
+  bool        isDebugInterface () const override { return false;                      }
+  const char *name             () const override { return tr_lts("dds", "ApHlaJson"); }
+
+private:
+  JsonDispatcher *m_adlerDispatcher;
+
+  std::shared_ptr<TrainingAreaBase::RecvFromTab>    m_recvFromTabCb;
+  const std::shared_ptr<TrainingAreaBase::TxMixin>  m_sendToTab;
+  std::shared_ptr<TrainingAreaBase::SendToTab>      m_mainHandlerTx;
+  TrainingAreaBase::Plugin::DataProvider           *m_pdp;
+
+  NGL::Settings *m_settings;
+
+  std::shared_ptr<PpmHandler> m_ppmHandler;
+  std::shared_ptr<PdmHandler> m_pdmHandler;
+  std::shared_ptr<AesHandler> m_aesHandler;
+  std::shared_ptr<FlmHandler> m_flmHandler;
+  std::shared_ptr<AsmHandler> m_asmHandler;
+  std::shared_ptr<TrainingAreaBase::DdsHandler> m_ddsHandler;
+
+  int m_domainId;
+  int m_exerciseId;
+};
+} // namespace AdlerJson
+
@@ -0,0 +1,44 @@
+/**
+  * @RDE_HEADER@
+  * PdmHandler for AdlerJson Plugin
+  * $Id: pdm_handler.h 62304 2024-03-21 08:17:45Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/pdm_handler.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include "main_dispatcher.h"
+#include "logger.h"
+#include <TrainingAreaBase/dds_handler.h>
+#include <ProjectDataManagement/pdm.hpp>
+#include <ProjectDataManagement/pdm_dtc.h>
+#include <LtsUtils/LtsUtilsCore/data_modification_enum.h>
+#include <QtCore/QObject>
+#include <QtCore/QHash>
+#include <QtCore/QUrl>
+#include <QtCore/QDateTime>
+
+namespace AdlerJson
+{
+
+class MainDispatcher;
+class PdmHandler : public QObject
+{
+  Q_OBJECT
+public:
+  explicit PdmHandler(QObject *parent = nullptr);
+  void getChargeTypes();
+  std::shared_ptr<ProjectDataManagement::Interface::Dtc> getDtc() { return m_dtcPdm; }
+signals:
+  void sendChargeTypes(QJsonObject jsonObj);
+public slots:
+  bool init(MainDispatcher* mainDispatcher);
+
+private:
+
+  std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_dtcPdm;
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,33 @@
+/**
+  * @RDE_HEADER@
+  * TabAdlerPlugin for AdlerJson Plugin
+  * $Id: plugin.h 62304 2024-03-21 08:17:45Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/plugin.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include "TrainingAreaBase/dds_handler.h"
+#include <QtCore/QObject>
+#include <TrainingAreaBase/tab_plugin_interface.h>
+
+namespace AdlerJson
+{
+class TabAdlerPlugin : public QObject, public TrainingAreaBase::Plugin::Plugin
+{
+  Q_OBJECT
+  Q_PLUGIN_METADATA(IID "special:3:tab.aphla")
+  Q_INTERFACES(TrainingAreaBase::Plugin::Plugin)
+public:
+  TabAdlerPlugin() = default;
+  ~TabAdlerPlugin() = default;
+  std::shared_ptr<TrainingAreaBase::Plugin::Interface> createInterface(TrainingAreaBase::Plugin::DataProvider *pdp,
+                                                                       const std::shared_ptr<TrainingAreaBase::RecvFromTab> &recvFromTabCb,
+                                                                       const std::shared_ptr<TrainingAreaBase::TxMixin> &sendToTab,
+                                                                       const std::shared_ptr<TrainingAreaBase::DdsHandler> &ddsHandler,
+                                                                       NGL::Settings *settings) override;
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,111 @@
+/**
+  * @RDE_HEADER@
+  * PpmHandler for AdlerJson Plugin
+  * $Id: ppm_handler.h 62899 2024-05-29 11:08:50Z ewert_j $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/ufom/Lts/Proxies/TrainingAreaBase/Plugins/AdlerJson/ppm_handler.h $
+  * $Author: ewert_j $
+  * Created by Julius Ewert, ESIM, 2024-03-20
+  */
+
+#pragma once
+
+#include "Core/core.hpp"
+#include "main_dispatcher.h"
+#include "logger.h"
+#include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm.hpp>
+#include <ParticipantManagement/ppm_ftc.h>
+#include <LtsUtils/LtsUtilsCore/data_modification_enum.h>
+#include <QtCore/QTimer>
+#include <QtCore/QObject>
+#include <QtCore/QHash>
+#include <QtCore/QUrl>
+#include <QtCore/QDateTime>
+#include <telegrams.h>
+
+namespace AdlerJson
+{
+
+class MainDispatcher;
+class PpmHandler
+    : public QObject
+    , protected ParticipantManagement::Interface::Ftc::ModifyParticipantDataReplyHandler
+    , protected ParticipantManagement::Interface::Ftc::ModifyPartyDataReplyHandler
+{
+  Q_OBJECT
+public:
+  explicit PpmHandler(QObject *parent = nullptr);
+  bool init(MainDispatcher* mainDispatcher);
+  void getParticipants();
+  bool isEqNumberInExercise(const int equipmentNumber) const;
+
+
+  std::shared_ptr<ParticipantManagement::Interface::Dtc> getDtc() { return m_dtcPpm; }
+  std::shared_ptr<ParticipantManagement::Interface::Ftc> getFtc() { return m_ftcPpm; }
+
+  void onCreateParticipant();
+
+  // ModifyParticipantDataRequestHandler interface
+  void onModifyParticipantDataReply(const Core::FunctionReply &reply);
+  void onModifyPartyDataReply(const Core::FunctionReply &reply);
+  void modifyPartyAdlerProperties(const int wsId, const int assetId, const int partyId, const QString &saaName, const QString &szenarName,
+                                  const ParticipantManagement::ConnectState &connectState, const bool isVerbund);
+
+  //parse functions that trigger other services
+  void parseSQFS(const Feuerstellungsdaten &exSQFS, const int wsId);
+  void parseSQWS(const Waffensystemdaten &exSQWS, const int wsId);
+  void parseSQLP(const Ladeplatzdaten &exSQLP, const int wsId);
+
+  void removeAllSAAParticipants(const int partyId);
+  ParticipantManagement::Participant findParticipantByInternalName(const QString &internalName, const int partyId, const bool isVerbund);
+
+signals:
+  void participantChanged(const QJsonObject &jsonObj);
+  void participantUnmount(const QJsonObject &jsonObj);
+  void participantMount(const QJsonObject &jsonObj);
+
+private slots:
+  void onPartyChanged(const ParticipantManagement::Party &data, DataModification modType);
+  void onParticipantChanged(const ParticipantManagement::Participant &data, DataModification modType);
+  void onParticipantPositionChanged(const ParticipantManagement::ParticipantPosition &data, DataModification modType);
+  void onDynamicParticipantDataChanged(const ParticipantManagement::DynamicParticipantData &data, DataModification modType);
+  void onSendParticipantDataTimeout();
+private:
+  void handleParticipantPositionChangedExternal(const ParticipantManagement::ParticipantPosition &position);
+  void handleParticipantPositionChangedInternal(const ParticipantManagement::ParticipantPosition &position);
+
+  void sendParticipantMount(const ParticipantManagement::Participant &part, const ParticipantManagement::Participant &partToBeMounted);
+  void sendParticipantUnmount(const ParticipantManagement::Participant &participant);
+  void sendParticipantPositionChanged(const ParticipantManagement::ParticipantPosition &position);
+  void onModifyParticipantDataReply(const Core::FunctionReplyObject &reply) override;
+  void onModifyPartyDataReply(const Core::FunctionReplyObject &reply) override;
+
+  QList<ParticipantManagement::Participant> findAllSAAParticipants(const int partyId);
+  ParticipantManagement::ParticipantData findParticipantDataByInternalName(int &randomNumberInOut, const QString &internalName, const bool isVerbund);
+  ParticipantManagement::ParticipantData findRootUnit(const int partyId);
+
+  void sendPositionFromTempMap(int rndNmbr, const int partyId, const bool isVerbund);
+  void sendChargesFromTempMap(const int rndNmbr, const int partyId, const bool isVerbund);
+  void sendReadyMessageFromTempMap(int rndNmbr, const int partyId, const bool isVerbund);
+  int convertStatus_L28(const ProjectDataManagement::L28_Status &status);
+
+  QVector<AdlerJson::Geschoss> sumUpAnzahlForSameGeschoss(const QVector<AdlerJson::Geschoss> &geschosse) const;
+private:
+  MainDispatcher *m_mainDispatcher;
+  std::shared_ptr<ParticipantManagement::Interface::Dtc> m_dtcPpm;
+  std::shared_ptr<ParticipantManagement::Interface::Ftc> m_ftcPpm;
+  QHash<int, int> m_participantIdsByEqNo; // eqNo, partId
+  QHash<int, int> m_mountedParticipants;// participantId of passanger, participantId of Vehicle
+  QTimer *m_sendParticipantDataTimer;
+  QVector<int> m_randomNumbers;
+  //maps
+  QMap<ProjectDataManagement::L19_Oi, KoordinateMitHoehe> m_mapLocationToPosition;
+  QMap<int, QMap<QString,KoordinateMitHoehe>> m_tempPositionMap;
+  QMap<int, QVector<QString>> m_tempinternalNameMap;
+  QMap<int,  QMap<QString,QVector<Geschoss>>> m_tempChargesMap;
+  QMap<int, std::vector<ParticipantManagement::ParticipantData>> m_tempPartDataList;
+  QMap<int, QMap<QString,ProjectDataManagement::L28_Status>> m_tempReadyMessage;
+
+};
+
+} // namespace AdlerJson
@@ -0,0 +1,103 @@
+#pragma once
+#include <QtCore/QString>
+#include <AdlerJson/telegrams.h>
+#include "ppm_handler.h"
+#include "aes_handler.h"
+#include "pdm_handler.h"
+
+#include "logger.h"
+
+// Forward:
+namespace LtsCoordTrans
+{
+struct  UtmCoordinate;
+}
+
+namespace AdlerJson
+{
+enum class ScenarioStatus // Szenarstatus
+{
+  NONE      ,
+  INACTIVE  , // Inaktiv
+  PLANNED   , // Geplant
+  ACTIVE    , // Aktiv
+  STOPPED     // Gestoppt
+};
+QString statusToStr(ScenarioStatus status);
+
+ScenarioStatus strToStatus(QString status);
+
+
+/**
+ * @brief Convert (relative) Flugbahnpunkt to EXCON coordinate system
+ * @param fbPos Flugbahnpunkt to be converted.
+ * @param transformMatrix QTransform to be applied (most likely rotation).
+ * @param utmLaunch launch coordinate for debugging purpose
+ * @param logger to be used.
+ * @return Coordinate transformed (rotated) in EXCON coordinate system.
+ */
+static Core::RelativePositionRelativeTime convertFlugbahnpunkt(const Flugbahnpunkt &fbPos,
+                                                               const QTransform &transformMatrix,
+                                                               const LtsCoordTrans::UtmCoordinate &utmLaunch,
+                                                               LOGGER_T logger);
+
+
+class JsonDispatcher;
+class SAAInterface
+    : public QObject
+    , protected AreaEffectSimulation::Interface::Ftc::TrajectoryAdlerModifyReplyHandler
+{
+  Q_OBJECT
+public:
+  SAAInterface(int wsId, int partyId, const QString& saaName, const QString& szenarName, bool isVerbund, QObject *parent = nullptr);
+
+  bool init(std::shared_ptr<PpmHandler>  ppmHandler,
+            std::shared_ptr<PdmHandler>  pdmHandler,
+            std::shared_ptr<AesHandler>  aesHandler,
+            std::shared_ptr<TrainingAreaBase::Interface::Dts> dtsTab);
+
+
+  int getWsId(){ return m_wsId; };
+  void setWsId(int wsId){ m_wsId = wsId;};
+  int getPartyId(){ return m_partyId; };
+  void setPartyId(int partyId){ m_partyId = partyId; };
+  QString getSAAName(){ return m_saaName; };
+  //QString getSAAName(){ return QStringLiteral("SAA.GUEZ.DE"); };
+  void setSaaName(const QString& saaName){ m_saaName = saaName; };
+  //void setSaaName(const QString& saaName){ Q_UNUSED(saaName); m_saaName = QStringLiteral("SAA@GUEZ.de"); };
+  QString getSzenarName() {return m_szenarName; }
+  void setSzenarName(const QString &szenarName) { m_szenarName = szenarName; }
+  Szenarstatus getStatus(){ return m_status; };
+  void setStatus(Szenarstatus status);
+  void setIsVerbund(bool isVerbund) { m_isVerbund = isVerbund; }
+  bool getIsVerbund(){ return m_isVerbund; }
+  void setIsAlive(bool isAlive) { m_isAlive = isAlive; }
+  bool getIsAlive(){ return m_isAlive; }
+
+  //parse functions that trigger other services
+  void parseFlugbahndaten(const Flugbahndaten &flugbahndaten, int aesItemId, int exposionId, const Core::GeoPosition &positionLaunch);
+
+  template<typename T>
+  void rxData         (const T &data      );
+
+private:
+  void onTrajectoryAdlerModifyReply(const Core::FunctionReplyObject &reply) override;
+
+  int m_wsId;
+  int m_partyId;
+  QString m_saaName;
+  QString m_szenarName;
+  Szenarstatus m_status;
+  bool m_isVerbund;
+  bool m_isAlive=false;
+
+  //int m_currentRandomNumber{0};
+  //DDS
+  std::shared_ptr<PpmHandler> m_ppmHandler;
+  std::shared_ptr<PdmHandler> m_pdmHandler;
+  std::shared_ptr<AesHandler> m_aesHandler;
+
+  std::shared_ptr<AreaEffectSimulation::Interface::Ftc> m_ftcAes;
+  std::shared_ptr<TrainingAreaBase::Interface::Dts>     m_dtsTab;
+};
+}
@@ -0,0 +1,33 @@
+/**
+  * Settings for TetraRadio
+  * $Id: settings.h 63154 2024-06-25 11:19:33Z karwat $
+  * $HeadURL: svn://slssvn/TDS/branches/product/features/24_adler/Lts/Proxies/TrainingAreaBase/settings.h $
+  * $Author: karwat $
+  * Created by Christian Ehrlicher, SLSE, 2016-04-14
+  */
+#pragma once
+
+#include <QtCore/QString>
+#include <QtCore/QJsonObject>
+
+namespace NGL
+{
+class Settings;
+}
+
+namespace TrainingAreaBase
+{
+
+namespace Settings
+{
+
+//!< The real NGL::Settings - object
+NGL::Settings *settings();
+
+void setIniFile(const QString &ini);
+QString txDir();
+QString rxDir();
+QPair<quint16, quint16> getWebSocketServerPortRange(int type);
+}
+
+} // namespace TrainingAreaBase
@@ -0,0 +1,78 @@
+#pragma once
+
+#include "ws_interface.h"
+#include "logger.h"
+
+#include <TrainingAreaBase/training_area_telegrams.h>
+#include <QtWebSockets/QWebSocketServer>
+#include <QtCore/QObject>
+#include <memory>
+
+
+namespace TrainingAreaBase
+{
+  class WebSocketWrapper;
+
+  class WebSocketHandler : public WebSocketInterface
+  {
+    Q_OBJECT
+  public:
+    explicit WebSocketHandler(QObject *parent = nullptr);
+    ~WebSocketHandler();
+
+    // WSInterface interface
+  public:
+    bool init(quint16 listenPort) override;
+    bool isConnected() const override;
+    quint16 getPort() const override;
+    bool sendTelegram(const int typeId, const QJsonObject *data, const int exerciseId) override;
+    bool sendTelegram(const int wsId, const QJsonObject *data) override;
+    bool disconnectWs(int wsId) override;
+    QString getPeerAddress(int wsId) const override;
+    QUrl getPeerUrl(int wsId) const override;
+
+    int getExerciseId(int wsId) const override;
+
+  //Q_SIGNALS:
+  //  void wsDisconnect(const int wsId);
+  private Q_SLOTS:
+    void onNewConnection();
+    void onWebSocketDisconnected();
+    void onTextMessageReceived(const QByteArray &baJson);
+  private:
+    bool sendTelegramInternal(const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *data, const QString &type, int exerciseId);
+    bool sendTelegramInternal(const int wsId, const TrainingAreaBase::TetraIcd::TrainingAreaTelegram *data, const QString &type, const int exerciseId);
+    int getWSIdFromWS( WebSocketWrapper* wsw );
+  private:
+      QWebSocketServer *m_webSocketServer;
+      //QVector<std::shared_ptr<WebSocketWrapper>> m_webSockets;
+      QMap<int, std::shared_ptr<WebSocketWrapper>> m_connections; // key = wsId
+
+      int m_nextWsId = 1;
+      AdlerJson::LOGGER_T           m_logger;
+  };
+
+  class WebSocketWrapper : public QObject
+  {
+    Q_OBJECT
+  public:
+    explicit WebSocketWrapper(QWebSocket *ws);
+    ~WebSocketWrapper();
+
+    bool sendTextMessage(const QString &msg);
+
+    void setExerciseId(int exerciseId);
+    void setWsId(int wsId){ m_wsId = wsId; }
+    int getWsId(){ return m_wsId; }
+    int exerciseId() const { return m_exerciseId; }
+    QWebSocket *webSocket() const { return m_webSocket; }
+  Q_SIGNALS:
+    void textMessageReceived(const QByteArray &data);
+  private Q_SLOTS:
+    void onTextMessageReceived(const QString &data);
+  private:
+    QWebSocket *m_webSocket;
+    int m_wsId;
+    int m_exerciseId;
+  };
+}
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <QtCore/QObject>
+#include <qobjectdefs.h>
+
+namespace TrainingAreaBase {
+
+  class WebSocketInterface : public QObject
+  {
+    Q_OBJECT
+  public:
+
+    virtual bool init(quint16 listenPort) = 0;
+    bool init(const QPair<quint16, quint16> &portRange)
+    {
+      for (quint16 currentPort = portRange.first; currentPort != portRange.second; ++currentPort)
+      {
+        if (init(currentPort))
+          return true;
+      }
+
+      return init(0);
+    }
+    virtual bool isConnected() const = 0;
+    virtual quint16 getPort() const = 0;
+
+    virtual bool disconnectWs(int wsId) = 0;
+
+    virtual bool sendTelegram(int typeId, const QJsonObject *data, int exerciseId) = 0;
+    virtual bool sendTelegram(int wsId, const QJsonObject *data) = 0;
+    virtual QString getPeerAddress(int wsId) const = 0;
+    virtual QUrl getPeerUrl(int wsId) const = 0;
+    virtual int getExerciseId(int wsId) const = 0;
+  Q_SIGNALS:
+    void recivedTelegram(int wsId, const QJsonObject& telegramData);
+    void newConnection(int wsId, const QString& address, qint16 port);
+    void wsDisconnected(int wsId);
+
+
+  public:
+    explicit WebSocketInterface(QObject* parent = nullptr) : QObject(parent){}
+    virtual ~WebSocketInterface() {}
+  };
+
+}
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AlarmManagement/alm_dtc.h>
@@ -0,0 +1,14 @@
+#pragma once
+
+// Translation Helper für AlarmManagement Module
+// Wrapper für QObject::tr() in nicht-QObject Klassen
+
+#include <QtCore/QString>
+#include "svcalmcommon_export.h"
+
+namespace AlarmManagement
+{
+
+SVCALMCOMMON_EXPORT QString tr(const char *sourceText, const char *comment = nullptr, int n = -1);
+
+} // namespace AlarmManagement
@@ -0,0 +1,49 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+#include <QtCore/QString>
+#include "almcommon_export.h"
+
+namespace AlarmManagement
+{
+
+// STUB: AlarmConfig - wird durch echten DDS-Typ ersetzt
+class ALMCOMMON_EXPORT AlarmConfig
+{
+public:
+    AlarmConfig() = default;
+    
+    int eventTypeId() const { return m_eventTypeId; }
+    void setEventTypeId(int id) { m_eventTypeId = id; }
+    
+    bool messageWindow() const { return m_messageWindow; }
+    void setMessageWindow(bool value) { m_messageWindow = value; }
+    
+    bool setMarker() const { return m_setMarker; }
+    void setSetMarker(bool value) { m_setMarker = value; }
+    
+    int participantId() const { return m_participantId; }
+    void setParticipantId(int id) { m_participantId = id; }
+    
+    int id() const { return m_id; }
+    void setId(int id) { m_id = id; }
+    
+    bool global() const { return m_global; }
+    void setGlobal(bool value) { m_global = value; }
+    
+    int vulnerabilityState() const { return m_vulnerabilityState; }
+    void setVulnerabilityState(int value) { m_vulnerabilityState = value; }
+
+private:
+    int m_eventTypeId = 0;
+    bool m_messageWindow = false;
+    bool m_setMarker = false;
+    int m_participantId = 0;
+    int m_id = 0;
+    bool m_global = false;
+    int m_vulnerabilityState = -1;
+};
+
+} // namespace AlarmManagement
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AreaEffectSimulation/aes_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AssetManagement/asm_dtc.h>
@@ -0,0 +1,322 @@
+/**
+  * STUB-HEADER: Diese Datei wird normalerweise von AudioVideoManagement generiert
+  * Für die Migration ohne RTI erstellen wir minimale Typ-Definitionen
+  */
+
+#pragma once
+
+#include <QtCore/QMetaType>
+#include "svcavmcommon_export.h"
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QVector>
+#include <QtCore/QPair>
+#include <chrono>
+#include <cstdint>
+
+namespace AudioVideoManagement
+{
+
+class StreamNameMapping;
+
+enum class AvaVisibility
+{
+  Visible = 1,
+  Hidden = 0
+};
+
+enum class AvaStreamState
+{
+  Stop = 0,
+  Start = 1,
+  Pause = 2,
+  NotPossible = 3
+};
+
+enum class AvaStreamType
+{
+  Audio = 1,
+  Video = 2
+};
+
+enum class AvaStreamSource
+{
+  Interface = 1, //!< live streams
+  Server = 2,    //!< stored streams for playback
+  Local = 4
+};
+
+enum class AvaScriptSource
+{
+  ServerAudio = 1,
+  ServerVideo = 2,
+  LocalAudio = 3,
+  LocalVideo = 4
+};
+
+enum class AvaElokaMode
+{
+  EndlessLoop = 0,
+  Once = 1
+};
+
+enum class AvaQueryElokaMode
+{
+  Stop = 0,  //!< stop previously requested asynchronous notifications
+  Poll = 1,  //!< poll active ELOKA measures once
+  Push = 2   //!< request asynchronous notifications from AVS
+};
+
+enum class AvaSumChannel
+{
+  Right = 1,
+  Left = 2
+};
+
+enum class AvaRtButtonState
+{
+  NotAvailable = 0,
+  None = 1,
+  Left = 2,
+  Right = 3,
+  Both = 4
+};
+
+class AVM_COMMON_EXPORT AvaSpeed
+{
+public:
+  explicit AvaSpeed(int speed = 0) : m_speed(speed) {}
+
+  operator int() const { return m_speed; }
+
+  static const QVector<int> &allowedValues()
+  {
+    static const QVector<int> values = {0, 25, 50, 75, 100, 125, 150, 175, 200};
+    return values;
+  }
+
+private:
+  int m_speed;
+};
+
+
+class AVM_COMMON_EXPORT AvaVolume
+{
+public:
+  explicit AvaVolume(int db = 0) : m_db(db) {}
+
+  operator int() const { return m_db; }
+
+  static AvaVolume min() { return AvaVolume(-50); }
+  static AvaVolume max() { return AvaVolume(20); }
+
+private:
+  int m_db;
+};
+
+
+class AVM_COMMON_EXPORT AvaAudioPrio
+{
+public:
+  explicit AvaAudioPrio(int prio = 0) : m_prio(prio) {}
+
+  operator int() const { return m_prio; }
+
+  static AvaAudioPrio min() { return AvaAudioPrio(0); }
+  static AvaAudioPrio max() { return AvaAudioPrio(255); }
+
+private:
+  int m_prio;
+};
+
+
+/**
+ * Position (index) of a radio circuit in the AVS_Workstation GUI.
+ * The index must be in [1, 8].
+ */
+class AVM_COMMON_EXPORT AvaRtPos
+{
+public:
+  explicit AvaRtPos(int pos = 1) : m_pos(pos) {}
+
+  operator int() const { return m_pos; }
+
+  static constexpr int min() { return 1; }
+  static constexpr int max() { return 8; }
+  static constexpr int count() { return max() - min() + 1; }
+
+private:
+  int m_pos;
+};
+
+
+enum class AvaGuiStyle
+{
+  Light = 0,
+  Dark
+};
+
+using AvaDuration = std::chrono::duration<int64_t, std::centi>;
+using AvaTimePoint = std::chrono::time_point<std::chrono::system_clock, AvaDuration>;
+
+/**
+ * Information about a stream in response to getStreamList.
+ */
+struct AVM_COMMON_EXPORT AvaStream
+{
+  /**
+   * @param nameWithSourceSpec is the AVS-internal stream name plus a source specifier that must match
+   *        the given AvaStreamSource, "(S)" for Server, "(L)" for Local, nothing for Interface.
+   */
+  static AvaStream create(AvaStreamType, AvaStreamSource, const QString &nameWithSourceSpec, StreamNameMapping *streamNameMapping)
+  {
+    Q_UNUSED(nameWithSourceSpec)
+    Q_UNUSED(streamNameMapping)
+    return AvaStream{};
+  }
+
+  /**
+   * Returns the AVS-internal stream name plus a source specifier at the end
+   * as described in create().
+   */
+  QString toString() const { return internalName; }
+  /** Same as toString() but for a vector of streams. */
+  static QStringList toStringList(const QVector<AvaStream> &streams)
+  {
+    QStringList result;
+    for (const auto &s : streams) {
+      result.append(s.toString());
+    }
+    return result;
+  }
+
+  bool operator==(const AvaStream &other) const
+  {
+    return type == other.type && source == other.source &&
+           internalName == other.internalName && displayName == other.displayName;
+  }
+  bool operator!=(const AvaStream &other) const { return !(*this == other); }
+
+  AvaStreamType type = AvaStreamType::Audio;
+  AvaStreamSource source = AvaStreamSource::Interface;
+  QString internalName; //!< AVS-internal stream name without source specifier
+  QString displayName;  //!< name to be displayed in the GUI without source specifier
+};
+
+/**
+ * Information about a stream as contained in StreamInfo in response to chooseStream.
+ */
+struct AVM_COMMON_EXPORT AvaStreamInfo
+{
+  AvaTimePoint start;
+  AvaTimePoint end;
+  AvaDuration duration;
+};
+
+
+using AvaTimelinePart = QPair<AvaTimePoint, AvaTimePoint>;
+
+class AVM_COMMON_EXPORT AvaTimeline
+{
+public:
+  AvaTimeline() = default;
+  explicit AvaTimeline(const QVector<AvaTimelinePart> &parts) : m_parts(parts) {}
+
+  bool isEmpty() const { return m_parts.isEmpty(); }
+
+  const AvaTimePoint &startTime() const
+  {
+    static AvaTimePoint dummy;
+    return m_parts.isEmpty() ? dummy : m_parts.first().first;
+  }
+  const AvaTimePoint &endTime() const
+  {
+    static AvaTimePoint dummy;
+    return m_parts.isEmpty() ? dummy : m_parts.last().second;
+  }
+
+  void clear() { m_parts.clear(); }
+  void append(const AvaTimelinePart &part) { m_parts.append(part); }
+  void merge(const AvaTimeline &other)
+  {
+    m_parts.append(other.m_parts);
+  }
+
+  const QVector<AvaTimelinePart> &parts() const { return m_parts; }
+
+  bool operator==(const AvaTimeline &other) const { return m_parts == other.m_parts; }
+  bool operator!=(const AvaTimeline &other) const { return m_parts != other.m_parts; }
+
+private:
+  void checkConsistency() const {}
+
+  QVector<AvaTimelinePart> m_parts;
+};
+
+
+/**
+ * Information about an eloka in response to queryEloka.
+ */
+struct AVM_COMMON_EXPORT AvaEloka
+{
+  QString signal;
+  QString stream;
+  qint32 priority = 0;
+  AvaTimePoint time;
+
+  bool operator==(const AvaEloka &other) const
+  {
+    return signal == other.signal && stream == other.stream &&
+           priority == other.priority && time == other.time;
+  }
+  bool operator!=(const AvaEloka &other) const { return !(*this == other); }
+};
+
+/**
+ * Information about a script entry.
+ */
+struct AVM_COMMON_EXPORT AvaScriptEntry
+{
+  bool operator==(const AvaScriptEntry &other) const
+  {
+    return name == other.name && speed == other.speed &&
+           start == other.start && stop == other.stop &&
+           db == other.db && mute == other.mute && pint == other.pint;
+  }
+  bool operator!=(const AvaScriptEntry &other) const { return !(*this == other); }
+
+  QString name;
+  AvaSpeed speed{100};
+  AvaTimePoint start;
+  AvaTimePoint stop;
+  AvaVolume db{0};
+  bool mute = false;
+  bool pint = false;
+};
+
+/**
+ * Represents the JSON data for a AV script topic in a C++ way.
+ */
+struct AVM_COMMON_EXPORT AvaTopicData
+{
+public:
+  explicit AvaTopicData(const QJsonObject &data) : m_isAudio(false), isValid(true)
+  {
+    Q_UNUSED(data)
+  }
+
+  bool isAudio() const { return m_isAudio; }
+  const QString &scriptName() const { return m_scriptName; }
+  const QVector<AvaScriptEntry> &streamList() const { return m_streamList; }
+
+  bool isValid = true;
+
+private:
+  bool m_isAudio = false;
+  QString m_scriptName;
+  QVector<AvaScriptEntry> m_streamList;
+};
+
+} // namespace AudioVideoManagement
+
+Q_DECLARE_METATYPE(AudioVideoManagement::AvaStream)
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/AudioVideoManagement/avm_dtc.h>
@@ -0,0 +1,13 @@
+/**
+  * Stub export header for non-RTI builds
+  * When BUILD_RTI=OFF, svcAvmCommon library is not built
+  * This stub allows dependent code to compile
+  */
+#pragma once
+
+#include <QtCore/qglobal.h>
+
+// Stub export macros for non-RTI builds
+#define AVM_COMMON_EXPORT
+#define AVM_CLIENT_EXPORT
+#define AVM_SERVER_EXPORT
@@ -0,0 +1,77 @@
+/**
+ * @file avm_translation.h
+ * @brief Translation functions for AudioVideoManagement enums
+ * 
+ * This file provides toString() functions for AVM enums used in CNR frequency planning.
+ */
+
+#ifndef AVM_TRANSLATION_H
+#define AVM_TRANSLATION_H
+
+#include <QtCore/QString>
+#include "avm_enums.hpp"
+
+namespace AudioVideoManagement {
+
+// RcOperatingMode toString - using actual enum values from stub
+inline QString toString(RcOperatingMode mode)
+{
+  switch (mode.underlying()) {
+    case RcOperatingMode::FixedFreqEncNone: return QStringLiteral("FixedFreqEncNone");
+    case RcOperatingMode::FixedFreqEncHwKr: return QStringLiteral("FixedFreqEncHwKr");
+    case RcOperatingMode::FixedFreqEncHwKrKl: return QStringLiteral("FixedFreqEncHwKrKl");
+    case RcOperatingMode::AkwEncNone: return QStringLiteral("AkwEncNone");
+    case RcOperatingMode::AkwEncEccm: return QStringLiteral("AkwEncEccm");
+    case RcOperatingMode::SIMPLEX: return QStringLiteral("SIMPLEX");
+    case RcOperatingMode::HALFDUPLEX: return QStringLiteral("HALFDUPLEX");
+    case RcOperatingMode::DUPLEX: return QStringLiteral("DUPLEX");
+    default: return QStringLiteral("Unknown");
+  }
+}
+
+// FrequencyBand toString
+inline QString toString(FrequencyBand band)
+{
+  switch (band.underlying()) {
+    case FrequencyBand::Undefined: return QStringLiteral("Undefined");
+    case FrequencyBand::HF: return QStringLiteral("HF");
+    case FrequencyBand::VHF: return QStringLiteral("VHF");
+    case FrequencyBand::UHF: return QStringLiteral("UHF");
+    case FrequencyBand::REL: return QStringLiteral("REL");
+    default: return QStringLiteral("Unknown");
+  }
+}
+
+// ModulationType toString
+inline QString toString(ModulationType mod)
+{
+  switch (mod.underlying()) {
+    case ModulationType::AM: return QStringLiteral("AM");
+    case ModulationType::FM: return QStringLiteral("FM");
+    default: return QStringLiteral("Unknown");
+  }
+}
+
+// ChannelSpacingHF toString
+inline QString toString(ChannelSpacingHF spacing)
+{
+  switch (spacing.underlying()) {
+    case ChannelSpacingHF::CS_100_Hz: return QStringLiteral("CS_100_Hz");
+    default: return QStringLiteral("Unknown");
+  }
+}
+
+// ChannelSpacing toString
+inline QString toString(ChannelSpacing spacing)
+{
+  switch (spacing.underlying()) {
+    case ChannelSpacing::CS_25_00_kHz: return QStringLiteral("CS_25_00_kHz");
+    case ChannelSpacing::CS_12_50_kHz: return QStringLiteral("CS_12_50_kHz");
+    case ChannelSpacing::CS_8_33_kHz: return QStringLiteral("CS_8_33_kHz");
+    default: return QStringLiteral("Unknown");
+  }
+}
+
+} // namespace AudioVideoManagement
+
+#endif // AVM_TRANSLATION_H
@@ -0,0 +1,13 @@
+#ifndef SVCAVMCOMMON_EXPORT_H
+#define SVCAVMCOMMON_EXPORT_H
+
+// Stub export header for non-RTI builds
+// When BUILD_RTI=OFF, svcAvmCommon library is not built
+// This stub allows dependent code to compile
+
+// Map to the actual macro names used in avm_export.h
+#define AVM_COMMON_EXPORT
+#define AVM_CLIENT_EXPORT
+#define AVM_SERVER_EXPORT
+
+#endif /* SVCAVMCOMMON_EXPORT_H */
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Buildings/bld_dtc.h>
@@ -0,0 +1,30 @@
+// Stub file for bld_enums.hpp - used when BUILD_RTI=OFF
+#ifndef BLD_ENUMS_HPP
+#define BLD_ENUMS_HPP
+
+#include <cstdint>
+
+namespace Buildings {
+
+enum class BuildingType : std::int32_t {
+    Residential = 0,
+    Commercial = 1,
+    Industrial = 2
+};
+
+enum class BuildingStatus : std::int32_t {
+    Active = 0,
+    Inactive = 1,
+    UnderConstruction = 2
+};
+
+struct BuildingInfo {
+    int id = 0;
+    double x = 0.0;
+    double y = 0.0;
+    double z = 0.0;
+};
+
+} // namespace Buildings
+
+#endif // BLD_ENUMS_HPP
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/CentralEffectSimulation/ces_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/CodificationManagement/cod_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ComponentMonitor/cmo_dtc.h>
@@ -0,0 +1,107 @@
+/**
+ * @file core.hpp
+ * @brief Core DDS Sammel-Header
+ * 
+ * Beinhaltet alle Core-Typen für DDS-Integration.
+ * 
+ * STUB: Diese Datei wird normalerweise von DDS generiert.
+ * Für die Qt6-Migration erstellen wir einen minimalen Stub.
+ */
+
+#pragma once
+
+#include <Core/core_types.h>
+#include <Core/core_enums.hpp>
+#include <Core/core_dtc.h>
+#include <ostream>
+
+namespace Core
+{
+/**
+ * @brief GeoPosition - Stub für DDS GeoPosition
+ * 
+ * Einfache Struktur für geographische Positionen.
+ */
+struct GeoPosition
+{
+    double longitude = 0.0;
+    double latitude = 0.0;
+    double altitude = 0.0;
+
+    GeoPosition() = default;
+    
+    GeoPosition(double lon, double lat, double z)
+        : longitude(lon)
+        , latitude(lat)
+        , altitude(z)
+    {
+    }
+
+    double lon() const { return longitude; }
+    double lat() const { return latitude; }
+    double z() const { return altitude; }
+
+    void lon(double lon) { longitude = lon; }
+    void lat(double lat) { latitude = lat; }
+    void z(double z) { altitude = z; }
+
+    void setLon(double lon) { longitude = lon; }
+    void setLat(double lat) { latitude = lat; }
+    void setZ(double z) { altitude = z; }
+};
+
+/**
+ * @brief GeoPosition2D - 2D GeoPosition (ohne Altitude)
+ * 
+ * Wird für Koordinaten ohne Höheninformation verwendet.
+ * Implizite Konversion von GeoPosition ermöglicht Downcast.
+ */
+struct GeoPosition2D
+{
+    double longitude = 0.0;
+    double latitude = 0.0;
+
+    GeoPosition2D() = default;
+    
+    GeoPosition2D(double lon, double lat)
+        : longitude(lon)
+        , latitude(lat)
+    {
+    }
+
+    // Implizite Konversion von GeoPosition (Downcast ignoriert altitude)
+    GeoPosition2D(const GeoPosition& pos)
+        : longitude(pos.lon())
+        , latitude(pos.lat())
+    {
+    }
+
+    double lon() const { return longitude; }
+    double lat() const { return latitude; }
+
+    void lon(double lon) { longitude = lon; }
+    void lat(double lat) { latitude = lat; }
+
+    void setLon(double lon) { longitude = lon; }
+    void setLat(double lat) { latitude = lat; }
+};
+
+/**
+ * @brief ostream operator für GeoPosition (Debug/Logging)
+ */
+inline std::ostream& operator<<(std::ostream& os, const GeoPosition& pos)
+{
+    os << "GeoPosition(lon=" << pos.lon() << ", lat=" << pos.lat() << ", alt=" << pos.z() << ")";
+    return os;
+}
+
+/**
+ * @brief ostream operator für GeoPosition2D (Debug/Logging)
+ */
+inline std::ostream& operator<<(std::ostream& os, const GeoPosition2D& pos)
+{
+    os << "GeoPosition2D(lon=" << pos.lon() << ", lat=" << pos.lat() << ")";
+    return os;
+}
+
+} // namespace Core
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Core/core_dtc.h>
@@ -0,0 +1,144 @@
+/**
+ * @file core_types.h
+ * @brief Core DDS-Typen Stubs
+ * 
+ * Minimalistische Definitionen für DDS-generierte Core-Typen.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+#include <QtCore/QString>
+
+namespace Core
+{
+
+/**
+ * @brief FunctionReplyObject - DDS-Stub für Function Reply Handling
+ * 
+ * Simuliert QString::arg() Verhalten und sammelt Argumente.
+ */
+class FunctionReplyObject
+{
+public:
+  explicit FunctionReplyObject(int id = -1, const char *str = nullptr)
+    : m_str(str ? str : std::string())
+    , m_id(id)
+  {}
+
+  explicit FunctionReplyObject(const char *str)
+    : m_str(str ? str : std::string())
+  {}
+
+  explicit FunctionReplyObject(int id, const std::string &errStr, const std::vector<std::string> &errArgs)
+    : m_str(errStr)
+    , m_args(errArgs)
+    , m_id(id)
+  {}
+
+  explicit FunctionReplyObject(int id, std::string &&errStr, std::vector<std::string> &&errArgs)
+    : m_str(std::move(errStr))
+    , m_args(std::move(errArgs))
+    , m_id(id)
+  {}
+
+  explicit FunctionReplyObject(int id, const std::string &errStr, const std::vector<std::string> &errArgs, const std::string &additionalInfo)
+    : m_str(errStr)
+    , m_additionalInfo(additionalInfo)
+    , m_args(errArgs)
+    , m_id(id)
+  {}
+
+  explicit FunctionReplyObject(int id, std::string &&errStr, std::vector<std::string> &&errArgs, std::string &&additionalInfo)
+    : m_str(std::move(errStr))
+    , m_additionalInfo(std::move(additionalInfo))
+    , m_args(std::move(errArgs))
+    , m_id(id)
+  {}
+
+  ~FunctionReplyObject() = default;
+
+  // simulate QString::arg() behaviour
+  FunctionReplyObject &arg(qint64 val) { (void)val; return *this; }
+  FunctionReplyObject &arg(const std::string &str) { m_args.push_back(str); return *this; }
+  FunctionReplyObject &arg(const QString &str) { m_args.push_back(str.toStdString()); return *this; }
+
+  /**
+   * @brief true if the object contains an error description
+   */
+  bool error() const { return !m_str.empty(); }
+  void setId(int id) { m_id = id; }
+  FunctionReplyObject &setStr(const char *str) { m_str = str; return *this; }
+  FunctionReplyObject &setAdditionalInfo(const char *additionalInfo) { m_additionalInfo = additionalInfo; return *this; }
+
+  int id() const { return m_id; }
+  std::string str() const { return m_str; }
+  std::string additionalInfo() const { return m_additionalInfo; }
+
+  std::vector<std::string> args() const { return m_args; }
+
+  /**
+   * @brief convert the error string and arguments to an untranslated std::string
+   */
+  std::string operator()() const { return m_str; }
+  
+  /**
+   * @brief convert and translate the error string and arguments to a translated QString
+   */
+  QString translated() const { return QString::fromStdString(m_str); }
+
+  int64_t uniqueId() const { return m_uniqueId; }
+  void setUniqueId(int64_t uniqueId) { m_uniqueId = uniqueId; }
+
+private:
+  std::string m_str;
+  std::string m_additionalInfo;
+  std::vector<std::string> m_args;
+  int64_t m_uniqueId = 0;
+  int m_id = -1;
+};
+
+/**
+ * @brief FunctionReply - Stub für DDS Function Reply bei BUILD_RTI=OFF
+ * 
+ * Minimaler Stub der API-Kompatibilität für request_helper.h bietet.
+ */
+class FunctionReply
+{
+public:
+  FunctionReply() = default;
+  
+  // Konstruktor für Kompatibilität mit FunctionReplyObject
+  FunctionReply(int id, const std::string& str, const std::vector<std::string>& args = {}, const std::string& additionalInfo = {})
+    : m_str(str)
+    , m_args(args)
+    , m_additionalInfo(additionalInfo)
+    , m_id(id)
+  {}
+  
+  ~FunctionReply() = default;
+  
+  int id() const { return m_id; }
+  void setId(int id) { m_id = id; }
+  
+  std::string str() const { return m_str; }
+  void setStr(const std::string& str) { m_str = str; }
+  
+  bool error() const { return !m_str.empty(); }
+  
+  int64_t uniqueId() const { return m_uniqueId; }
+  void setUniqueId(int64_t uniqueId) { m_uniqueId = uniqueId; }
+  
+  std::vector<std::string> args() const { return m_args; }
+  std::string additionalInfo() const { return m_additionalInfo; }
+
+private:
+  std::string m_str;
+  std::vector<std::string> m_args;
+  std::string m_additionalInfo;
+  int m_id = -1;
+  int64_t m_uniqueId = 0;
+};
+
+} // namespace Core
@@ -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
@@ -0,0 +1,357 @@
+/**
+  * @RDE_HEADER@
+  * DataTopicClient (DTC) - Generic
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#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 <dds/core/cond/StatusCondition.hpp>
+#include <dds/core/cond/WaitSet.hpp>
+
+#include "generic_dtc.h"
+
+
+namespace DDSGeneric
+{
+class DynamicDataReader;
+} // namespace DDSGeneric
+
+namespace DTC
+{
+
+template<typename SuperClass>
+class GenericDtcImplSubscriberTemplate : public DDSGeneric::SubscriberListenerCallback, public SuperClass
+{
+public:
+  using DataReaderObject =   typename SuperClass::DataReaderObject;
+  using SubscriberCallback = typename SuperClass::SubscriberCallback;
+  using TopicTypeRead =      typename DataReaderObject::TopicType;
+  using TopicTypeSubscribe = typename DataReaderObject::TopicType;
+  using DataReader =         typename DataReaderObject::DataReader;
+
+  GenericDtcImplSubscriberTemplate(const dds::domain::DomainParticipant &domainParticipant,
+                                   const dds::sub::Subscriber &ddsSubscriber,
+                                   DDSGeneric::SubscriberListener *subscriberListener,
+                                   const std::string &topicName = DDS::Helper::getShortTopicName(DDS::topic_type_name<TopicTypeRead>::value()))
+    : m_subscriberListener(subscriberListener)
+    , m_dataReaderObject(new DataReaderObject)
+    , m_subscriberCallback(nullptr)
+    , m_writerState(0)
+    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicTypeRead>::value(), DDS::DataType::DATA_TOPIC_CLIENT))
+  {
+    createInternal(m_dataReaderObject->create(domainParticipant, ddsSubscriber, topicName));
+  }
+
+  GenericDtcImplSubscriberTemplate(const dds::domain::DomainParticipant &domainParticipant,
+                                   const dds::sub::Subscriber &ddsSubscriber,
+                                   DDSGeneric::SubscriberListener *subscriberListener,
+                                   const dds::topic::Filter &filter,
+                                   const std::string &topicName)
+    : m_subscriberListener(subscriberListener)
+    , m_dataReaderObject(new DataReaderObject)
+    , m_subscriberCallback(nullptr)
+    , m_writerState(0)
+    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicTypeRead>::value(), DDS::DataType::DATA_TOPIC_CLIENT))
+  {
+    createInternal(m_dataReaderObject->create(domainParticipant, ddsSubscriber, topicName, filter));
+  }
+
+  GenericDtcImplSubscriberTemplate(const dds::domain::DomainParticipant &domainParticipant,
+                                   const dds::sub::Subscriber &ddsSubscriber,
+                                   DDSGeneric::SubscriberListener *subscriberListener,
+                                   const dds::core::xtypes::StructType &structType,
+                                   const std::string &topicName)
+    : m_subscriberListener(subscriberListener)
+    , m_dataReaderObject(new DataReaderObject)
+    , m_subscriberCallback(nullptr)
+    , m_logger(DDS::getLogger(DDS::topic_type_name<TopicTypeRead>::value(), DDS::DataType::DATA_TOPIC_CLIENT))
+  {
+    createInternal(m_dataReaderObject->create(domainParticipant, ddsSubscriber, topicName, structType));
+  }
+
+  ~GenericDtcImplSubscriberTemplate()
+  {
+    if (m_dataReaderObject && m_subscriberCallback)
+      m_subscriberListener->removeCallback(m_dataReaderObject->getDataReader(), this);
+    delete m_dataReaderObject;
+  }
+
+  bool setSubscriberCallback(const SubscriberCallback &subscriberCallback) override final
+  {
+    if (m_subscriberCallback)
+    {
+      WARNING_LOG(m_logger) << "Can not set subscriber callback - already set ...";
+      return false;
+    }
+    if (!m_subscriberListener)
+    {
+      WARNING_LOG(m_logger) << "Can not set subscriber callback - no subscriber listener ...";
+      return false;
+    }
+
+    m_subscriberCallback = subscriberCallback;
+
+    if (!m_dataReaderObject)
+    {
+      WARNING_LOG(m_logger) << "Can not set subscriber callback - no data reader object ...";
+      return false;
+    }
+
+    m_dataReaderObject->setHaveSubscriberCallback(m_subscriberCallback != nullptr);
+
+    return true;
+  }
+
+  dds::sub::LoanedSamples<TopicTypeRead> readAlive() const override final
+  {
+    if (!m_dataReaderObject)
+      return dds::sub::LoanedSamples<TopicTypeRead>();
+
+    bool bSeenUnreadSamples = false;
+    auto ret = m_dataReaderObject->readAlive(bSeenUnreadSamples);
+    if (bSeenUnreadSamples)
+      QTimer::singleShot(0, this, &GenericDtcImplSubscriberTemplate::unreadSamplesDuringRead);
+
+    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)
+      return dds::sub::LoanedSamples<TopicTypeRead>();
+
+    bool bSeenUnreadSamples = false;
+    auto ret = m_dataReaderObject->takeAlive(bSeenUnreadSamples);
+    if (bSeenUnreadSamples)
+      QTimer::singleShot(0, this, &GenericDtcImplSubscriberTemplate::unreadSamplesDuringRead);
+
+    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)
+      return dds::sub::LoanedSamples<TopicTypeRead>();
+
+    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)
+      return false;
+
+    return m_dataReaderObject->hasSamples();
+  }
+
+  DataReaderObject *dataReader() const override final
+  {
+    return m_dataReaderObject;
+  }
+
+  bool waitForHistoricalData(int timeoutMSec) override
+  {
+    if (m_dataReaderObject == nullptr ||
+        m_dataReaderObject->getDataReader() == nullptr)
+      return false;
+
+    const bool bWaitForever = (timeoutMSec < 0);
+    auto dr = m_dataReaderObject->getDataReader();
+    try
+    {
+      if (dr.subscription_matched_status().current_count() == 0)
+      {
+        dds::core::cond::WaitSet ws;
+        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));
+        const dds::core::cond::WaitSet::ConditionSeq seq(ws.wait(waitTimeout));
+        // empty sequence -> timeout
+        if (seq.empty())
+          return false;
+      }
+      dr.wait_for_historical_data(dds::core::Duration(1));
+    }
+    catch (const dds::core::Exception &)
+    {
+      // timeout
+      return false;
+    }
+    return true;
+  }
+
+protected:
+  void unreadSamplesDuringRead()
+  {
+    droDataAvailable(DDS::topic_type_name<TopicTypeRead>::value(), m_dataReaderObject->topicName());
+  }
+
+  void droDataAvailable(const std::string &topicType, const std::string &topicName) override final
+  {
+    Q_UNUSED(topicType);
+    if (m_writerState.testAndSetRelaxed(1, 0))
+    {
+      DEBUG_LOG(m_logger) << "Recreate Reader for topic " << topicName
+                          << ", type name " << DDS::topic_type_name<TopicTypeRead>::value();
+      if (m_subscriberListener)
+        m_subscriberListener->removeCallback(m_dataReaderObject->getDataReader(), this);
+      m_dataReaderObject->recreateReader();
+      if (m_subscriberListener)
+        m_subscriberListener->addCallback(m_dataReaderObject->getDataReader(), this);
+    }
+
+    DEBUG_LOG(m_logger) << "IN droDataAvailable(), topic name: " << topicName
+                        << ", type name " << DDS::topic_type_name<TopicTypeRead>::value()
+                        << ", this: " << this
+                        << ", m_dataReaderObject: " << m_dataReaderObject
+                        << ", hasSamples: " << (m_dataReaderObject ? m_dataReaderObject->hasSamples() : -1);
+
+    if (m_subscriberListener)
+      m_subscriberListener->enableCallback(m_dataReaderObject->getDataReader(), this);
+
+    if (!m_dataReaderObject || !m_subscriberCallback)
+      return;
+
+    m_dataReaderObject->read(m_subscriberCallback);
+  }
+
+  void noWriterAnymore(const std::string &topicType, const std::string &topicName) override
+  {
+    Q_UNUSED(topicType);
+    Q_UNUSED(topicName);
+    m_writerState = -1;
+  }
+
+  void writerAvailable(const std::string &topicType, const std::string &topicName) override
+  {
+    Q_UNUSED(topicType);
+    Q_UNUSED(topicName);
+    m_writerState.testAndSetRelaxed(-1, 1);
+  }
+
+  bool createInternal(bool droInitOk)
+  {
+    if (!droInitOk)
+    {
+      ERROR_LOG(m_logger) << "Error initializing DRO for type " << DDS::topic_type_name<TopicTypeRead>::value();
+      delete m_dataReaderObject;
+      m_dataReaderObject  = nullptr;
+      return false;
+    }
+
+    if (m_subscriberListener)
+    {
+      DEBUG_LOG(m_logger) << "subscriberListener exists, adding type "
+                          << DDS::topic_type_name<TopicTypeRead>::value();
+      m_subscriberListener->addCallback(m_dataReaderObject->getDataReader(), this);
+    }
+    else
+    {
+      DEBUG_LOG(m_logger) << "Cannot add DTC to subscriberListener callback - type: "
+                          << DDS::topic_type_name<TopicTypeRead>::value();
+    }
+    m_dataReaderObject->setHaveSubscriberCallback(m_subscriberListener != nullptr);
+    return true;
+  }
+
+private:
+  DDSGeneric::SubscriberListener  *m_subscriberListener;
+
+  // DataReaderObjects (DROs)
+  DataReaderObject                *m_dataReaderObject;
+
+  // Callback for data processing
+  SubscriberCallback               m_subscriberCallback;
+
+  QAtomicInt m_writerState;
+
+  NGL::INGLLogger                 &m_logger;
+};
+
+// Typed topic callback (DataReader)
+template<typename DRO_OBJECT>
+class GenericDtcImpl final
+    : public GenericDtcImplSubscriberTemplate<GenericDtc<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<GenericDtc<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+// Typed topic callback (DataReader) with SampleInfo
+template<typename DRO_OBJECT>
+class GenericDtcImplSampleInfo final
+    : public GenericDtcImplSubscriberTemplate<GenericDtcSampleInfo<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<GenericDtcSampleInfo<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+// Dynamic topic callback (DynamicDataReader)
+template<typename DRO_OBJECT>
+class DdtcImpl final
+    : public GenericDtcImplSubscriberTemplate<Ddtc<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<Ddtc<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+// Dynamic topic callback (DynamicDataReader) with SampleInfo
+template<typename DRO_OBJECT>
+class DdtcImplSampleInfo final
+    : public GenericDtcImplSubscriberTemplate<DdtcSampleInfo<DRO_OBJECT>>
+{
+  using BaseClass = GenericDtcImplSubscriberTemplate<DdtcSampleInfo<DRO_OBJECT>>;
+public:
+  using BaseClass::BaseClass;
+};
+
+}  // namespace DTC
@@ -0,0 +1,32 @@
+#pragma once
+
+// Stub header for BUILD_RTI=OFF
+// Original ddsconnector_export.h is generated by CMake when BUILD_RTI=ON
+
+// For BUILD_RTI=OFF, we don't need DLL export/import macros
+// Define DDSCONNECTOR_EXPORT as empty
+#ifndef DDSCONNECTOR_EXPORT
+#define DDSCONNECTOR_EXPORT
+#endif
+
+#ifndef DDSCONNECTOR_NO_EXPORT
+#define DDSCONNECTOR_NO_EXPORT
+#endif
+
+// Static library marker (not used for BUILD_RTI=OFF)
+#ifndef DDSCONNECTOR_STATIC_DEFINE
+#define DDSCONNECTOR_STATIC_DEFINE
+#endif
+
+// Deprecated marker (optional, can be empty)
+#ifndef DDSCONNECTOR_DEPRECATED
+#define DDSCONNECTOR_DEPRECATED
+#endif
+
+#ifndef DDSCONNECTOR_DEPRECATED_EXPORT
+#define DDSCONNECTOR_DEPRECATED_EXPORT DDSCONNECTOR_DEPRECATED DDSCONNECTOR_EXPORT
+#endif
+
+#ifndef DDSCONNECTOR_DEPRECATED_NO_EXPORT
+#define DDSCONNECTOR_DEPRECATED_NO_EXPORT DDSCONNECTOR_DEPRECATED DDSCONNECTOR_NO_EXPORT
+#endif
@@ -0,0 +1,32 @@
+#pragma once
+
+// Stub header for BUILD_RTI=OFF
+// Original ddsgen_export.h comes from RTI Connext DDS code generation
+
+// For BUILD_RTI=OFF, we don't need DLL export/import macros
+// Define DDSGEN_EXPORT as empty
+#ifndef DDSGEN_EXPORT
+#define DDSGEN_EXPORT
+#endif
+
+#ifndef DDSGEN_NO_EXPORT
+#define DDSGEN_NO_EXPORT
+#endif
+
+// Static library marker (not used for BUILD_RTI=OFF)
+#ifndef DDSGEN_STATIC_DEFINE
+#define DDSGEN_STATIC_DEFINE
+#endif
+
+// Deprecated marker (optional, can be empty)
+#ifndef DDSGEN_DEPRECATED
+#define DDSGEN_DEPRECATED
+#endif
+
+#ifndef DDSGEN_DEPRECATED_EXPORT
+#define DDSGEN_DEPRECATED_EXPORT DDSGEN_DEPRECATED DDSGEN_EXPORT
+#endif
+
+#ifndef DDSGEN_DEPRECATED_NO_EXPORT
+#define DDSGEN_DEPRECATED_NO_EXPORT DDSGEN_DEPRECATED DDSGEN_NO_EXPORT
+#endif
@@ -0,0 +1,51 @@
+#pragma once
+
+// Stub header for BUILD_RTI=OFF
+// Original generic_base.h uses RTI Connext DDS types
+
+#include <string>
+#include <ddsgen_export.h>
+#include <QMetaMethod>
+
+// Forward declarations for Qt types used in getMethod
+class QObject;
+
+// Forward declaration for NGL logger
+namespace NGL {
+class INGLLogger;
+}
+
+namespace DDS
+{
+
+// Template for topic type name - returns empty string for BUILD_RTI=OFF
+template<typename T>
+struct topic_type_name {
+    static std::string value() {
+        return "";
+    }
+};
+
+namespace Helper
+{
+// Stub implementations for BUILD_RTI=OFF
+DDSGEN_EXPORT inline std::string getFunctionTopicName(const std::string &fqName) {
+    return fqName;
+}
+
+DDSGEN_EXPORT inline std::string getShortTopicName(const std::string &fqName) {
+    return fqName;
+}
+
+// Stub for getMethod - returns default-constructed QMetaMethod
+DDSGEN_EXPORT inline QMetaMethod getMethod(NGL::INGLLogger & /*logger*/,
+                                           QObject * /*objectToInform*/,
+                                           const char * /*slotToExecute*/,
+                                           const char * /*signalSignature*/,
+                                           bool /*bWarnOnEmptySlot*/ = true) {
+    // Stub implementation - returns default QMetaMethod
+    return QMetaMethod();
+}
+}
+
+} // namespace DDS
@@ -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
@@ -0,0 +1,84 @@
+#pragma once
+
+#ifdef BUILD_RTI
+// Real implementation with RTI NGL logger
+#include <NGLLogger/INGLLogger.h>
+#include <ddsgen_export.h>
+#include <string>
+
+namespace DDS
+{
+
+enum class DataType
+{
+  DATA_TYPE_UNKNOWN   = 0,
+
+  DATA_WRITER         = 1,
+  DATA_READER         = 2,
+
+  DYNAMIC_DATA_WRITER = 3,
+  DYNAMIC_DATA_READER = 4,
+
+  DATA_TOPIC_SERVER   = 8,
+  DATA_TOPIC_CLIENT   = 9,
+
+  FUNCTION_TOPIC_SERVER = 12,
+  FUNCTION_TOPIC_CLIENT = 13
+};
+
+using LOGGER_T = NGL::INGLLogger&;
+
+DDSGEN_EXPORT LOGGER_T getLogger(const char *name, DataType dt);
+inline LOGGER_T getLogger(const std::string &loggerName, DataType dt)
+{
+  return getLogger(loggerName.data(), dt);
+}
+
+} // namespace DDS
+#else
+// Stub header for BUILD_RTI=OFF
+#include <NGLLogger/INGLLogger.h>
+#include <ddsgen_export.h>
+#include <string>
+
+namespace DDS
+{
+
+// DataType enum - same as original, no RTI dependency
+enum class DataType
+{
+  DATA_TYPE_UNKNOWN   = 0,
+
+  DATA_WRITER         = 1,
+  DATA_READER         = 2,
+
+  DYNAMIC_DATA_WRITER = 3,
+  DYNAMIC_DATA_READER = 4,
+
+  DATA_TOPIC_SERVER   = 8,
+  DATA_TOPIC_CLIENT   = 9,
+
+  FUNCTION_TOPIC_SERVER = 12,
+  FUNCTION_TOPIC_CLIENT = 13
+};
+
+// Logger type alias
+using LOGGER_T = NGL::INGLLogger&;
+
+// Stub implementation for getLogger
+// Returns a dummy logger reference - in real usage, this would need proper initialization
+DDSGEN_EXPORT inline LOGGER_T getLogger(const char *name, DataType dt) {
+    // Stub: return a static dummy logger
+    // In production code with BUILD_RTI=OFF, this should be replaced with actual logger
+    static NGL::INGLLogger* dummy_logger = nullptr;
+    return *dummy_logger;
+}
+
+// Inline overload for std::string
+inline LOGGER_T getLogger(const std::string &loggerName, DataType dt)
+{
+  return getLogger(loggerName.data(), dt);
+}
+
+} // namespace DDS
+#endif
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/EffectShowClient/esc_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/EffectShowManagement/esm_dtc.h>
@@ -0,0 +1,31 @@
+/**
+  * @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 <QObject>
+
+namespace Evaluations
+{
+
+/**
+ * @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 QObject
+{
+  Q_OBJECT
+public:
+  explicit DatabaseInterfaceImpl(QObject *parent = nullptr) : QObject(parent) {}
+  virtual ~DatabaseInterfaceImpl() = default;
+
+  // Virtual methods that can be overridden by custom implementations
+  virtual bool removeCategoryLinesPerNineLiner(qint64 nineLinerId) = 0;
+};
+
+} // namespace Evaluations
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Evaluations/evl_dtc.h>
@@ -0,0 +1,10 @@
+#pragma once
+
+// Convenience header for ExerciseEventManagement
+// Includes all common types and enums
+
+#include <ExerciseEventManagement/eem_enums.hpp>
+#include <ExerciseEventManagement/eem_dtc.h>
+#include <ExerciseEventManagement/eem_types.h>
+
+// Additional forward declarations and common types can be added here
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ExerciseEventManagement/eem_dtc.h>
@@ -0,0 +1,11 @@
+/**
+  * Stub export header for ExerciseEventManagement non-RTI builds
+  * When BUILD_RTI=OFF, svcEemCommon library is not built
+  * This stub allows dependent code to compile
+  */
+#pragma once
+
+#include <QtCore/qglobal.h>
+
+// Stub export macros for non-RTI builds
+#define EEM_EXPORT
@@ -0,0 +1,37 @@
+/**
+  * Stub type definitions for ExerciseEventManagement
+  * When BUILD_RTI=OFF, DDS-generated types are not available
+  * This stub allows dependent code to compile
+  */
+#pragma once
+
+#include <ExerciseEventManagement/eem_export.h>
+#include <QtCore/QString>
+#include <QtCore/QDateTime>
+#include <memory>
+
+namespace ExerciseEventManagement
+{
+
+/**
+ * @brief Stub Event type for non-RTI builds
+ */
+struct EEM_EXPORT Event
+{
+  Event() = default;
+  ~Event() = default;
+  
+  // Basic fields - adjust based on actual usage
+  QString id;
+  QString type;
+  QDateTime timestamp;
+  QString description;
+  
+  // Copy/move operations
+  Event(const Event&) = default;
+  Event(Event&&) = default;
+  Event& operator=(const Event&) = default;
+  Event& operator=(Event&&) = default;
+};
+
+} // namespace ExerciseEventManagement
@@ -0,0 +1,165 @@
+#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 "exm_enums.hpp"
+#include <QString>
+#include <QDateTime>
+#include <QByteArray>
+#include <vector>
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace ExerciseManagement
+{
+
+// Forward declarations
+class Exercise;
+class ExercisePhase;
+
+/**
+ * @brief Exercise class - Stub für DDS-generierten Code
+ * 
+ * Diese Klasse wird normalerweise von DDS aus exm_service.xml generiert.
+ * Für BUILD_RTI=OFF verwenden wir diese minimale Implementierung.
+ */
+class Exercise
+{
+public:
+  Exercise()
+      : m_id(0)
+      , m_stateId(0)
+      , m_operatorId(0)
+      , m_workstationId(0)
+      , m_trainingAreaId(0)
+      , m_radioGroupId(std::nullopt)
+      , m_activePhaseId(std::nullopt)
+      , m_symbolFillTypeId(0)
+      , m_linkedExerciseId(std::nullopt)
+      , m_sendToWms(false)
+      , m_transferred(false)
+      , m_hasHlaInterface(false)
+  {}
+  
+  // Getter
+  int32_t id() const { return m_id; }
+  std::string name() const { return m_name.toStdString(); }
+  QString nameQString() const { return m_name; }
+  int32_t stateId() const { return m_stateId; }
+  int32_t operatorId() const { return m_operatorId; }
+  int32_t workstationId() const { return m_workstationId; }
+  QDateTime beginTime() const { return m_beginTime; }
+  QDateTime endTime() const { return m_endTime; }
+  QDateTime created() const { return m_created; }
+  QDateTime startTime() const { return m_startTime; }
+  QDateTime stopTime() const { return m_stopTime; }
+  int32_t trainingAreaId() const { return m_trainingAreaId; }
+  std::optional<int32_t> radioGroupId() const { return m_radioGroupId; }
+  std::optional<int32_t> activePhaseId() const { return m_activePhaseId; }
+  int32_t symbolFillTypeId() const { return m_symbolFillTypeId; }
+  std::optional<int32_t> linkedExerciseId() const { return m_linkedExerciseId; }
+  QString defaultTimeZone() const { return m_defaultTimeZone; }
+  bool sendToWms() const { return m_sendToWms; }
+  QString forces() const { return m_forces; }
+  QString description() const { return m_description; }
+  bool transferred() const { return m_transferred; }
+  bool hasHlaInterface() const { return m_hasHlaInterface; }
+  
+  // 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 setStateId(int32_t stateId) { m_stateId = stateId; }
+  void setOperatorId(int32_t operatorId) { m_operatorId = operatorId; }
+  void setWorkstationId(int32_t workstationId) { m_workstationId = workstationId; }
+  void setBeginTime(const QDateTime& time) { m_beginTime = time; }
+  void setEndTime(const QDateTime& time) { m_endTime = time; }
+  void setCreated(const QDateTime& time) { m_created = time; }
+  void setStartTime(const QDateTime& time) { m_startTime = time; }
+  void setStopTime(const QDateTime& time) { m_stopTime = time; }
+  void setTrainingAreaId(int32_t id) { m_trainingAreaId = id; }
+  void setRadioGroupId(std::optional<int32_t> id) { m_radioGroupId = id; }
+  void setActivePhaseId(std::optional<int32_t> id) { m_activePhaseId = id; }
+  void setSymbolFillTypeId(int32_t id) { m_symbolFillTypeId = id; }
+  void setLinkedExerciseId(std::optional<int32_t> id) { m_linkedExerciseId = id; }
+  void setDefaultTimeZone(const QString& tz) { m_defaultTimeZone = tz; }
+  void setSendToWms(bool send) { m_sendToWms = send; }
+  void setForces(const QString& forces) { m_forces = forces; }
+  void setDescription(const QString& desc) { m_description = desc; }
+  void setTransferred(bool transferred) { m_transferred = transferred; }
+  void setHasHlaInterface(bool has) { m_hasHlaInterface = has; }
+  
+  // Utility
+  bool isValid() const { return m_id > 0; }
+  
+private:
+  int32_t m_id;
+  QString m_name;
+  int32_t m_stateId;
+  int32_t m_operatorId;
+  int32_t m_workstationId;
+  QDateTime m_beginTime;
+  QDateTime m_endTime;
+  QDateTime m_created;
+  QDateTime m_startTime;
+  QDateTime m_stopTime;
+  int32_t m_trainingAreaId;
+  std::optional<int32_t> m_radioGroupId;
+  std::optional<int32_t> m_activePhaseId;
+  int32_t m_symbolFillTypeId;
+  std::optional<int32_t> m_linkedExerciseId;
+  QString m_defaultTimeZone;
+  bool m_sendToWms;
+  QString m_forces;
+  QString m_description;
+  bool m_transferred;
+  bool m_hasHlaInterface;
+};
+
+/**
+ * @brief ExercisePhase class - Stub für DDS-generierten Code
+ * 
+ * Diese Klasse wird normalerweise von DDS aus exm_service.xml generiert.
+ * Für BUILD_RTI=OFF verwenden wir diese minimale Implementierung.
+ */
+class ExercisePhase
+{
+public:
+  ExercisePhase()
+      : m_id(0)
+      , m_exerciseId(0)
+  {}
+  
+  // Getter
+  int32_t id() const { return m_id; }
+  std::string name() const { return m_name.toStdString(); }
+  QString nameQString() const { return m_name; }
+  QString description() const { return m_description; }
+  QDateTime beginTime() const { return m_beginTime; }
+  QDateTime endTime() const { return m_endTime; }
+  int32_t exerciseId() const { return m_exerciseId; }
+  
+  // 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 setDescription(const QString& desc) { m_description = desc; }
+  void setBeginTime(const QDateTime& time) { m_beginTime = time; }
+  void setEndTime(const QDateTime& time) { m_endTime = time; }
+  void setExerciseId(int32_t id) { m_exerciseId = id; }
+  
+  // Utility
+  bool isValid() const { return m_id > 0; }
+  
+private:
+  int32_t m_id;
+  QString m_name;
+  QString m_description;
+  QDateTime m_beginTime;
+  QDateTime m_endTime;
+  int32_t m_exerciseId;
+};
+
+} // namespace ExerciseManagement
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ExerciseManagement/exm_dtc.h>
@@ -0,0 +1,110 @@
+/**
+  * ExerciseManagement Function Topic Client interface
+  * STUB-HEADER: Diese Datei wird normalerweise von DDS generiert
+  * Für die Migration erstellen wir minimale Implementierungen
+  */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <QObject>
+
+namespace DDSConnector
+{
+class DdsConnector;
+}
+
+namespace ExerciseManagement
+{
+namespace Interface
+{
+
+// Forward declaration
+class Ftc;
+
+// Reply Handler stub classes for Function Topics
+// These are normally generated from DDS IDL definitions
+
+class GetExerciseDataReplyHandler
+{
+public:
+  GetExerciseDataReplyHandler() = default;
+  virtual ~GetExerciseDataReplyHandler() = default;
+  virtual void onGetExerciseData(const void* /*reply*/) {}
+};
+
+class ModifyExerciseDataReplyHandler
+{
+public:
+  ModifyExerciseDataReplyHandler() = default;
+  virtual ~ModifyExerciseDataReplyHandler() = default;
+  virtual void onModifyExerciseData(const void* /*reply*/) {}
+};
+
+class GetExercisePhaseDataReplyHandler
+{
+public:
+  GetExercisePhaseDataReplyHandler() = default;
+  virtual ~GetExercisePhaseDataReplyHandler() = default;
+  virtual void onGetExercisePhaseData(const void* /*reply*/) {}
+};
+
+// Ftc - Function Topic Client interface for ExerciseManagement
+class Ftc : public QObject
+{
+  Q_OBJECT
+  
+public:
+  virtual ~Ftc() = default;
+  
+  /**
+   * Create a new instance for ExerciseManagement::Interface::Ftc.
+   * STUB: Returns nullptr - actual implementation would require DDS
+   */
+  static std::shared_ptr<Ftc> create(const std::shared_ptr<DDSConnector::DdsConnector>& /*ddsConnector*/, bool /*forceCreate*/ = false)
+  {
+    return nullptr;
+  }
+  
+  /**
+   * A unique identifier for this FTC
+   */
+  static inline const char* identifier() { return "ExerciseManagement.Interface.Ftc"; }
+  
+  /**
+   * Initialize this Ftc instance with all function topic clients
+   */
+  virtual bool enableAll(bool /*enable*/ = true) { return false; }
+  
+  /**
+   * Enable/disable specific function topic clients
+   */
+  virtual bool enableGetExerciseData(bool /*enable*/ = true) { return false; }
+  virtual bool isGetExerciseDataEnabled() const { return false; }
+  
+  virtual bool enableModifyExerciseData(bool /*enable*/ = true) { return false; }
+  virtual bool isModifyExerciseDataEnabled() const { return false; }
+  
+  virtual bool enableGetExercisePhaseData(bool /*enable*/ = true) { return false; }
+  virtual bool isGetExercisePhaseDataEnabled() const { return false; }
+  
+  /**
+   * Request methods with reply handlers
+   * STUB: Return -1 to indicate no request was sent
+   */
+  virtual int64_t requestGetExerciseData(const void* /*request*/, GetExerciseDataReplyHandler* /*handler*/) { return -1; }
+  virtual int64_t requestGetExerciseData(const void* /*request*/, const std::function<void(const void*)>& /*cb*/) { return -1; }
+  virtual int64_t lastGetExerciseDataUniqueId() const { return -1; }
+  
+  virtual int64_t requestModifyExerciseData(const void* /*request*/, ModifyExerciseDataReplyHandler* /*handler*/) { return -1; }
+  virtual int64_t requestModifyExerciseData(const void* /*request*/, const std::function<void(const void*)>& /*cb*/) { return -1; }
+  virtual int64_t lastModifyExerciseDataUniqueId() const { return -1; }
+  
+  virtual int64_t requestGetExercisePhaseData(const void* /*request*/, GetExercisePhaseDataReplyHandler* /*handler*/) { return -1; }
+  virtual int64_t requestGetExercisePhaseData(const void* /*request*/, const std::function<void(const void*)>& /*cb*/) { return -1; }
+  virtual int64_t lastGetExercisePhaseDataUniqueId() const { return -1; }
+};
+
+} // namespace Interface
+} // namespace ExerciseManagement
@@ -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/
+)
@@ -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
@@ -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
@@ -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
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/FileManagement/flm_dtc.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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/GuezIedManagement/gim_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/GuezNasat/gna_dtc.h>
@@ -0,0 +1,18 @@
+
+
+
+#pragma once
+
+#include <NGLLogger/INGLLogger.h>
+#include "gna_export.h"
+
+namespace GuezNasat
+{
+using LOGGER_T = NGL::INGLLogger &;
+
+GNA_COMMON_EXPORT LOGGER_T getLogger(const char *name);
+inline LOGGER_T getLogger(const QString &loggerName)
+{
+  return getLogger(loggerName.toUtf8().constData());
+}
+} 
@@ -0,0 +1,233 @@
+/**
+ * @file ism.hpp
+ * @brief DDS-Stub-Header für InfrastructureManagement
+ * 
+ * Dieser Header ersetzt die von RTI DDS Generator erzeugten Typen.
+ */
+
+#ifndef ISM_HPP
+#define ISM_HPP
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <QtCore/QString>
+#include <QtCore/QByteArray>
+#include <QtGui/QImage>
+#include <QtCore/QMap>
+#include "InfrastructureManagement/ism_enums.hpp"
+#include "ParticipantManagement/ppm.hpp"
+#include "ParticipantManagement/ppm_enums.hpp"
+
+namespace InfrastructureManagement {
+
+// Using-declaration for DataModification in InfrastructureManagement namespace
+using ParticipantManagement::DataModification;
+
+// Core namespace mit GeoPosition und RelativePosition
+namespace Core {
+
+class GeoPosition {
+public:
+    GeoPosition() : latitude_(0.0), longitude_(0.0), altitude_(0.0) {}
+    double latitude() const { return latitude_; }
+    double longitude() const { return longitude_; }
+    double altitude() const { return altitude_; }
+    void latitude(double v) { latitude_ = v; }
+    void longitude(double v) { longitude_ = v; }
+    void altitude(double v) { altitude_ = v; }
+private:
+    double latitude_;
+    double longitude_;
+    double altitude_;
+};
+
+class RelativePosition {
+public:
+    RelativePosition() : x_(0.0), y_(0.0), z_(0.0) {}
+    double x() const { return x_; }
+    double y() const { return y_; }
+    double z() const { return z_; }
+    void x(double v) { x_ = v; }
+    void y(double v) { y_ = v; }
+    void z(double v) { z_ = v; }
+private:
+    double x_;
+    double y_;
+    double z_;
+};
+
+} // namespace Core
+
+// StructureElement Stub-Klasse
+class StructureElement {
+public:
+    StructureElement() : id_(0), mainStructureElementId_(0), mountingPointTypeId_(MountingPointType::Undefined), mountingPointId_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    int32_t mainStructureElementId() const { return mainStructureElementId_; }
+    void mainStructureElementId(int32_t v) { mainStructureElementId_ = v; }
+    
+    MountingPointType mountingPointTypeId() const { return mountingPointTypeId_; }
+    void mountingPointTypeId(MountingPointType v) { mountingPointTypeId_ = v; }
+    
+    // Für Kompatibilität: structureElementTypeId() als Alias
+    MountingPointType structureElementTypeId() const { return mountingPointTypeId_; }
+    void structureElementTypeId(MountingPointType v) { mountingPointTypeId_ = v; }
+    
+    // mountingPointId() für Sub-ID
+    int32_t mountingPointId() const { return mountingPointId_; }
+    void mountingPointId(int32_t v) { mountingPointId_ = v; }
+    
+    Core::GeoPosition geoPosition() const { return geoPosition_; }
+    void geoPosition(const Core::GeoPosition& v) { geoPosition_ = v; }
+    
+    Core::RelativePosition relPosition() const { return relPosition_; }
+    void relPosition(const Core::RelativePosition& v) { relPosition_ = v; }
+    
+    std::string properties() const { return properties_; }
+    void properties(const std::string& v) { properties_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+    std::string displayName() const { return displayName_; }
+    void displayName(const std::string& v) { displayName_ = v; }
+    
+    // path() returns vector of IDs im Hierarchie-Pfad
+    const std::vector<int32_t>& path() const { return path_; }
+    void path(const std::vector<int32_t>& v) { path_ = v; }
+    
+private:
+    int32_t id_;
+    int32_t mainStructureElementId_;
+    MountingPointType mountingPointTypeId_;
+    int32_t mountingPointId_;
+    Core::GeoPosition geoPosition_;
+    Core::RelativePosition relPosition_;
+    std::string properties_;
+    std::string name_;
+    std::string displayName_;
+    std::vector<int32_t> path_;
+};
+
+// MainStructureElement - Stub für DDS-generierten Typ
+class MainStructureElement {
+public:
+    MainStructureElement() : id_(0), groupId_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    int32_t groupId() const { return groupId_; }
+    void groupId(int32_t v) { groupId_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+    std::string displayName() const { return displayName_; }
+    void displayName(const std::string& v) { displayName_ = v; }
+    
+    Core::GeoPosition geoPosition() const { return geoPosition_; }
+    void geoPosition(const Core::GeoPosition& v) { geoPosition_ = v; }
+    
+    // For compatibility: elements() returns empty vector by default
+    const std::vector<StructureElement>& elements() const { return elements_; }
+    void elements(const std::vector<StructureElement>& v) { elements_ = v; }
+    
+private:
+    int32_t id_;
+    int32_t groupId_;
+    std::string name_;
+    std::string displayName_;
+    Core::GeoPosition geoPosition_;
+    std::vector<StructureElement> elements_;
+};
+
+// MountingPointAsset - Stub für DDS-generierten Typ
+class MountingPointAsset {
+public:
+    MountingPointAsset() : id_(0), mountingPointId_(0), assetId_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    int32_t mountingPointId() const { return mountingPointId_; }
+    void mountingPointId(int32_t v) { mountingPointId_ = v; }
+    
+    int32_t assetId() const { return assetId_; }
+    void assetId(int32_t v) { assetId_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+    // For compatibility: structureElementId() alias for mountingPointId()
+    int32_t structureElementId() const { return mountingPointId_; }
+    void structureElementId(int32_t v) { mountingPointId_ = v; }
+    
+private:
+    int32_t id_;
+    int32_t mountingPointId_;
+    int32_t assetId_;
+    std::string name_;
+};
+
+// Forward declaration - full definition in ism_mounting_point.h
+class MountingPoint;
+
+// FootprintElement - für Footprint-Daten
+class FootprintElement {
+public:
+    FootprintElement() : isGroundLevel_(false) {}
+    
+    bool isGroundLevel() const { return isGroundLevel_; }
+    void isGroundLevel(bool v) { isGroundLevel_ = v; }
+    
+    Core::RelativePosition relPosition() const { return relPosition_; }
+    void relPosition(const Core::RelativePosition& v) { relPosition_ = v; }
+    
+private:
+    bool isGroundLevel_;
+    Core::RelativePosition relPosition_;
+};
+
+// MainFootprint - Footprint-Daten für MainStructureElement
+class MainFootprint {
+public:
+    MainFootprint() : id_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    const std::vector<FootprintElement>& elements() const { return elements_; }
+    void elements(const std::vector<FootprintElement>& v) { elements_ = v; }
+    
+private:
+    int32_t id_;
+    std::vector<FootprintElement> elements_;
+};
+
+// InstrumentationAsset - Stub für DDS-generierten Typ
+class InstrumentationAsset {
+public:
+    InstrumentationAsset() : id_(0) {}
+    
+    int32_t id() const { return id_; }
+    void id(int32_t v) { id_ = v; }
+    
+    std::string name() const { return name_; }
+    void name(const std::string& v) { name_ = v; }
+    
+private:
+    int32_t id_;
+    std::string name_;
+};
+
+// StructureElementType Enum (Alias für MountingPointType für Kompatibilität)
+using StructureElementType = MountingPointType;
+
+} // namespace InfrastructureManagement
+
+#endif // ISM_HPP
@@ -0,0 +1,46 @@
+/**
+  * @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 <QObject>
+#include <InfrastructureManagement/ism_enums.hpp>
+
+namespace Database
+{
+// Stub struct for IsmMountingPointPlan
+struct IsmMountingPointPlan
+{
+  int scheduleId = 0;
+  int mountingPointId = 0;
+  MountingPointState mountingPointState = MountingPointState::Unknown;
+};
+} // namespace Database
+
+namespace InfrastructureManagement
+{
+
+/**
+ * @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 QObject
+{
+  Q_OBJECT
+public:
+  explicit DatabaseInterfaceImpl(QObject *parent = nullptr) : QObject(parent) {}
+  virtual ~DatabaseInterfaceImpl() = default;
+
+  // Virtual methods that can be overridden by custom implementations
+  virtual int copySchedule(int scheduleId) = 0;
+  virtual bool updateMountingPointPlan(int scheduleId, int mountingPointId, MountingPointState mountingPointState) = 0;
+  virtual bool deleteMountingPointPlan(int scheduleId, int mountingPointId) = 0;
+  virtual bool insertMountingPointPlans(const std::vector<Database::IsmMountingPointPlan> &mpps) = 0;
+};
+
+} // namespace InfrastructureManagement
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/InfrastructureManagement/ism_dtc.h>
@@ -0,0 +1,11 @@
+#pragma once
+// STUB-HEADER: Diese Datei wird normalerweise von ddsftc generiert
+// Für die Migration erstellen wir minimale Forward-Declarations
+
+namespace InfrastructureManagement
+{
+namespace Interface
+{
+  class Ftc;
+}
+}
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/MarkerManagement/mrk_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/Messaging/msg_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/MeteoDataManagement/mdm_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/NotificationManagement/nom_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/OcSituationServer/oss_dtc.h>
@@ -0,0 +1,133 @@
+#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 "opm_enums.hpp"
+#include <QString>
+#include <QDateTime>
+#include <QByteArray>
+#include <vector>
+#include <cstdint>
+#include <memory>
+#include <optional>
+
+namespace OperatorManagement
+{
+
+// Forward declarations
+class Operator;
+class Group;
+
+/**
+ * @brief Operator class - Stub für DDS-generierten Code
+ * 
+ * Diese Klasse wird normalerweise von DDS aus opm_service.xml generiert.
+ * Für BUILD_RTI=OFF verwenden wir diese minimale Implementierung.
+ */
+class Operator
+{
+public:
+  Operator()
+      : m_id(0)
+      , m_groupId(0)
+      , m_accessLevel(0)
+      , m_isActive(false)
+      , m_isHidden(false)
+  {}
+  
+  // Getter
+  int32_t id() const { return m_id; }
+  std::string name() const { return m_name.toStdString(); }
+  QString nameQString() const { return m_name; }
+  int32_t groupId() const { return m_groupId; }
+  std::string description() const { return m_description.toStdString(); }
+  QByteArray image() const { return m_image; }
+  int32_t accessLevel() const { return m_accessLevel; }
+  bool isActive() const { return m_isActive; }
+  bool isHidden() const { return m_isHidden; }
+  QDateTime created() const { return m_created; }
+  QDateTime modified() const { return m_modified; }
+  
+  // 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 setGroupId(int32_t groupId) { m_groupId = groupId; }
+  void setDescription(const QString& description) { m_description = description; }
+  void setImage(const QByteArray& image) { m_image = image; }
+  void setAccessLevel(int32_t accessLevel) { m_accessLevel = accessLevel; }
+  void setIsActive(bool active) { m_isActive = active; }
+  void setIsHidden(bool hidden) { m_isHidden = hidden; }
+  void setCreated(const QDateTime& created) { m_created = created; }
+  void setModified(const QDateTime& modified) { m_modified = modified; }
+  
+  // Utility
+  bool isValid() const { return m_id > 0; }
+  
+private:
+  int32_t m_id;
+  QString m_name;
+  int32_t m_groupId;
+  QString m_description;
+  QByteArray m_image;
+  int32_t m_accessLevel;
+  bool m_isActive;
+  bool m_isHidden;
+  QDateTime m_created;
+  QDateTime m_modified;
+};
+
+/**
+ * @brief Group class - Stub für DDS-generierten Code
+ * 
+ * Diese Klasse wird normalerweise von DDS aus opm_service.xml generiert.
+ * Für BUILD_RTI=OFF verwenden wir diese minimale Implementierung.
+ */
+class Group
+{
+public:
+  Group()
+      : m_id(0)
+      , m_typeId(0)
+      , m_isHidden(false)
+  {}
+  
+  // Getter
+  int32_t id() const { return m_id; }
+  std::string name() const { return m_name.toStdString(); }
+  QString nameQString() const { return m_name; }
+  std::string description() const { return m_description.toStdString(); }
+  int32_t typeId() const { return m_typeId; }
+  bool isHidden() const { return m_isHidden; }
+  std::vector<int32_t> memberIds() const { return m_memberIds; }
+  
+  // 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 setDescription(const QString& description) { m_description = description; }
+  void setTypeId(int32_t typeId) { m_typeId = typeId; }
+  void setIsHidden(bool hidden) { m_isHidden = hidden; }
+  void setMemberIds(const std::vector<int32_t>& ids) { m_memberIds = ids; }
+  
+  // Utility
+  bool isValid() const { return m_id > 0; }
+  void addMember(int32_t operatorId) { m_memberIds.push_back(operatorId); }
+  void removeMember(int32_t operatorId)
+  {
+    m_memberIds.erase(
+        std::remove(m_memberIds.begin(), m_memberIds.end(), operatorId),
+        m_memberIds.end());
+  }
+  
+private:
+  int32_t m_id;
+  QString m_name;
+  QString m_description;
+  int32_t m_typeId;
+  bool m_isHidden;
+  std::vector<int32_t> m_memberIds;
+};
+
+} // namespace OperatorManagement
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/OperatorManagement/opm_dtc.h>
@@ -0,0 +1,93 @@
+/**
+  * @RDE_HEADER@
+  * OperatorManagement DTC Implementation
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Stub-Header für Qt6-Migration - ersetzt DDS-generierten Header
+  */
+#pragma once
+
+#include <FileManagement/flm_db_impl.h>
+#include <QHash>
+#include <memory>
+
+// Forward declarations für DDS
+namespace DDSConnector
+{
+class DdsConnector;
+}
+
+// User-Klasse Stub für Qt6-Migration
+// Hinweis: Diese Klasse wird normalerweise von DDS generiert
+// Dieser Stub stellt die benötigten Methoden für opm_dtc_impl_custom.cpp bereit
+class User
+{
+public:
+  int id() const { return m_id; }
+  QString name() const { return m_name; }
+  QVector<int> effectiveAcls() const { return m_effectiveAcls; }
+  
+  struct VisiblePartyByExercise
+  {
+    int exerciseId() const { return m_exerciseId; }
+    std::optional<QVector<int>> visibleParties() const { return m_visibleParties; }
+    std::optional<QVector<int>> hiddenParties() const { return m_hiddenParties; }
+    QString properties() const { return m_properties; }
+    
+    int m_exerciseId = 0;
+    std::optional<QVector<int>> m_visibleParties;
+    std::optional<QVector<int>> m_hiddenParties;
+    QString m_properties;
+  };
+  
+  QVector<VisiblePartyByExercise> visiblePartiesByExercise() const { return m_visiblePartiesByExercise; }
+  QVector<int> exerciseIds() const { return m_exerciseIds; }
+  QString properties() const { return m_properties; }
+  
+private:
+  int m_id = 0;
+  QString m_name;
+  QVector<int> m_effectiveAcls;
+  QVector<VisiblePartyByExercise> m_visiblePartiesByExercise;
+  QVector<int> m_exerciseIds;
+  QString m_properties;
+};
+
+//-------------------------------------------------------------------------------------------------------------
+namespace OperatorManagement
+{
+namespace Interface
+{
+/**
+ * @brief DtcImpl - Basisklasse für OperatorManagement DTC
+ * 
+ * Stellt Logger und User-Container für Custom-Implementierungen bereit
+ * Erbt von FileManagement::DatabaseInterfaceImpl für Datenbank-Zugriff
+ */
+class DtcImpl : public FileManagement::DatabaseInterfaceImpl
+{
+public:
+  explicit DtcImpl(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
+    : FileManagement::DatabaseInterfaceImpl()
+    , m_ddsConnector(ddsConnector)
+  {
+    // Logger wird von DatabaseInterfaceImpl bereitgestellt
+    // m_logger ist in DatabaseInterfaceImpl definiert
+  }
+
+  ~DtcImpl() override = default;
+
+  // Virtuelle Methoden für Custom-Implementierung
+  virtual std::vector<int> getOperatorsByOperatorRight(int operatorRight) = 0;
+  virtual std::vector<int> operatorForExerciseParty(int exerciseId, int partyId) = 0;
+  virtual std::vector<int> getNotificationRecipents(int exerciseId, int partyId, int operatorRight, int notificationType) = 0;
+  virtual bool isAdlerAllowedParty(int exerciseId, int partyId, int operatorId) = 0;
+
+protected:
+  std::shared_ptr<DDSConnector::DdsConnector> m_ddsConnector;
+  QHash<int, User> m_userCont;  // User-Container für Operator-Daten
+};
+
+} // namespace Interface
+} // namespace OperatorManagement
@@ -0,0 +1,21 @@
+#ifndef OPM_FTC_H
+#define OPM_FTC_H
+
+// Stub header for OperatorManagement FTC functionality
+// This file is part of FilterManagement which is excluded from build
+// For non-FilterManagement builds, we provide this stub
+
+#include <QtCore/QString>
+#include <QtCore/QObject>
+
+// Forward declarations and stubs for FTC (Filter/Translation/Conversion)
+// Actual implementation is in FilterManagement plugin
+
+class OpmFtc
+{
+public:
+    virtual ~OpmFtc() = default;
+    // Stub methods - actual implementation in FilterManagement
+};
+
+#endif // OPM_FTC_H
@@ -0,0 +1,182 @@
+#pragma once
+// STUB-HEADER: Diese Datei wird normalerweise von DDS generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+#include <ParticipantManagement/ppm_enums.hpp>
+
+#include <QtCore/QObject>
+#include <QtCore/QString>
+#include <QtCore/QList>
+#include <QtCore/QMap>
+#include <functional>
+#include <memory>
+#include <ostream>
+
+namespace ParticipantManagement
+{
+
+// Type - Struct mit id und typeClass (nicht nur Alias!)
+struct Type {
+  int id = 0;
+  TypeClass typeClass = TypeClass::eUninitialized;
+  
+  // Helper methods für Kompatibilität (andere Namen als Member!)
+  int getId() const { return id; }
+  TypeClass getTypeClass() const { return typeClass; }
+};
+
+// Participant - Basisdaten eines Teilnehmers
+struct Participant {
+  int m_id = 0;
+  QString internalName;
+  QString externalName;
+  int typeId = 0;
+  int partyId = 0;
+  bool isVerbund = false;
+  int superiorId = 0;
+  
+  // Additional fields as needed
+  double x = 0.0;
+  double y = 0.0;
+  double z = 0.0;
+  double heading = 0.0;
+  
+  // Optional fields (für DDS-Kompatibilität)
+  std::optional<int> equipmentNumber;
+  QString m_designator;
+  QString m_tacticalIdentifier;
+  
+  // Helper methods
+  QString name() const { return internalName; }
+  QString designator() const { return m_designator; }
+  QString tacticalIdentifier() const { return m_tacticalIdentifier; }
+  std::optional<int> getEquipmentNumber() const { return equipmentNumber; }
+  int id() const { return m_id; }
+};
+
+// Party - Gruppe/Organisation von Teilnehmern
+struct Party {
+  int id = 0;
+  QString name;
+  QString shortName;
+  int color() const { return 0xFF000000; } // Default schwarz als QRgb
+};
+
+// ParticipantPosition - Position eines Teilnehmers
+struct ParticipantPosition {
+  int participantId = 0;
+  double x = 0.0;
+  double y = 0.0;
+  double z = 0.0;
+  double heading = 0.0;
+  double speed = 0.0;
+  qint64 timestamp = 0;
+};
+
+// DynamicParticipantData - Dynamische Teilnehmerdaten
+struct DynamicParticipantData {
+  int participantId = 0;
+  QString status;
+  QString role;
+  qint64 lastUpdate = 0;
+};
+
+// MainSchedule - Stub für DDS-generierten Typ
+struct MainSchedule {
+  int32_t id = 0;
+  QString name;
+  QString description;
+  qint64 startTime = 0;
+  qint64 endTime = 0;
+  bool isActive = false;
+};
+
+namespace Interface
+{
+
+// Using-Declaration für DataModification aus Parent-Namespace
+using ParticipantManagement::DataModification;
+
+// Dtc - Data Transfer Component für Participant Management
+// DDS-generierte Klasse mit participantChanged Signal
+class Dtc : public QObject {
+  Q_OBJECT
+  
+public:
+  Dtc() = default;
+  ~Dtc() override = default;
+  
+  // Teilnehmer-Liste abrufen (Callback-basiert wie im Original)
+  void participants(const std::function<void(const Participant&)>& callback) const {
+    for (const auto& p : m_participants) {
+      callback(p);
+    }
+  }
+  
+  // Teilnehmer-Liste als QList (für direkten Zugriff)
+  QList<Participant> participantsList() const { return m_participants; }
+  
+  // Teilnehmer hinzufügen/entfernen/ändern
+  void addParticipant(const Participant& p) { 
+    m_participants.append(p); 
+    emit participantChanged(p, DataModification::eAdded);
+  }
+  
+  void updateParticipant(const Participant& p) {
+    for (auto& existing : m_participants) {
+      if (existing.m_id == p.m_id) {
+        existing = p;
+        emit participantChanged(p, DataModification::eModified);
+        return;
+      }
+    }
+    addParticipant(p);
+  }
+  
+  void removeParticipant(int id) {
+    for (auto it = m_participants.begin(); it != m_participants.end(); ++it) {
+      if (it->m_id == id) {
+        Participant removed = *it;
+        m_participants.erase(it);
+        emit participantChanged(removed, DataModification::eRemoved);
+        return;
+      }
+    }
+  }
+  
+  // Hierarchy-Methoden (STUB)
+  QString hierarchyFromParticipant(int participantId) const {
+    Q_UNUSED(participantId);
+    return QString();
+  }
+  
+  // Party-Methoden (STUB)
+  Party party(int partyId) const {
+    Q_UNUSED(partyId);
+    return Party();
+  }
+  
+signals:
+  // Signal für Teilnehmer-Änderungen
+  void participantChanged(const Participant& participant, DataModification modificationType);
+  
+private:
+  QList<Participant> m_participants;
+  QMap<int, QString> m_hierarchies;
+  QMap<int, Party> m_parties;
+};
+
+} // namespace Interface
+
+// Stream operator for logging
+inline std::ostream& operator<<(std::ostream& os, const Type& t) {
+    os << "Type(id=" << t.id << ", typeClass=" << t.typeClass << ")";
+    return os;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Participant& p) {
+    os << "Participant(id=" << p.m_id << ", name=" << p.name().toStdString() << ")";
+    return os;
+}
+
+} // namespace ParticipantManagement
@@ -0,0 +1,41 @@
+/**
+  * @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 <QObject>
+
+namespace Database
+{
+// Stub struct for EquipmentExerciseMapping
+struct EquipmentExerciseMapping
+{
+  int equipmentId = 0;
+  int exerciseId = 0;
+};
+} // namespace Database
+
+namespace ParticipantManagement
+{
+
+/**
+ * @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 QObject
+{
+  Q_OBJECT
+public:
+  explicit DatabaseInterfaceImpl(QObject *parent = nullptr) : QObject(parent) {}
+  virtual ~DatabaseInterfaceImpl() = default;
+
+  // Virtual methods that can be overridden by custom implementations
+  virtual bool removeEquipmentExerciseMapping(const Database::EquipmentExerciseMapping &equipmentExerciseMapping) = 0;
+};
+
+} // namespace ParticipantManagement
@@ -0,0 +1,44 @@
+#pragma once
+
+// DDS-Stub-Header für ParticipantManagement FTC (Filter Topic Client)
+// Generiert für Qt6-Migration ohne RTI DDS
+
+#include <ParticipantManagement/ppm.hpp>
+#include <Core/core_types.h>
+#include <functional>
+#include <memory>
+#include <map>
+
+namespace ParticipantManagement
+{
+namespace Interface
+{
+
+class Ftc
+{
+public:
+  class ModifyTypeReplyHandler
+  {
+  public:
+    virtual ~ModifyTypeReplyHandler() = default;
+    virtual void onModifyTypeReply(const Core::FunctionReplyObject &replyObject) = 0;
+  };
+  
+  Ftc() = default;
+  virtual ~Ftc() = default;
+  
+  virtual std::map<int32_t, Type> getTypes() const
+  {
+    return std::map<int32_t, Type>();
+  }
+  
+  virtual Type type(int32_t typeId) const
+  {
+    Type t;
+    t.id = typeId;
+    return t;
+  }
+};
+
+} // namespace Interface
+} // namespace ParticipantManagement
@@ -0,0 +1,14 @@
+#pragma once
+
+// Translation Helper für ParticipantManagement Module
+// Wrapper für QObject::tr() in nicht-QObject Klassen
+
+#include <QtCore/QString>
+#include "ppmcommon_export.h"
+
+namespace ParticipantManagement
+{
+
+PPMCOMMON_EXPORT QString tr(const char *sourceText, const char *comment = nullptr, int n = -1);
+
+} // namespace ParticipantManagement
@@ -0,0 +1,40 @@
+#pragma once
+
+// STUB-HEADER: Diese Datei wird normalerweise von ddsdtc generiert
+// Für die Migration erstellen wir minimale Typ-Definitionen
+
+#include <QtCore/QString>
+#include <ostream>
+#include <ParticipantManagement/ppm_enums.hpp>
+
+namespace ParticipantManagement
+{
+
+// STUB: Type - wird durch echten DDS-Typ ersetzt
+struct Type
+{
+    int id = 0;
+    QString name;
+    TypeClass typeClass = TypeClass::eUninitialized;
+    // Weitere Felder werden bei Bedarf ergänzt
+};
+
+// STUB: Participant - wird durch echten DDS-Typ ersetzt
+struct Participant
+{
+    int id = 0;
+    QString name;
+    QString callsign;
+    Type type;
+    // Weitere Felder werden bei Bedarf ergänzt
+};
+
+// Stream-Operator für Logger-Unterstützung
+inline std::ostream& operator<<(std::ostream& os, const Participant& participant)
+{
+    os << "Participant(id=" << participant.id << ", name=" << participant.name.toStdString() 
+       << ", callsign=" << participant.callsign.toStdString() << ")";
+    return os;
+}
+
+} // namespace ParticipantManagement
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/PresentationManagement/pre_dtc.h>
@@ -0,0 +1,259 @@
+/**
+ * Stub implementation for DtcImpl base class
+ * Qt6 Migration - provides minimal stub implementations
+ */
+
+#include "pdm_dtc_impl.h"
+#include <QJsonObject>
+
+namespace ProjectDataManagement
+{
+namespace Interface
+{
+
+DtcImpl::DtcImpl(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector)
+    : m_ddsConnector(ddsConnector)
+{
+}
+
+DtcImpl::~DtcImpl() = default;
+
+// Data access methods - stub implementations
+ChargeTypeData DtcImpl::chargeType(int /*chargeTypeId*/)
+{
+  return ChargeTypeData();
+}
+
+IgniterType DtcImpl::igniterType(int /*igniterTypeId*/)
+{
+  return IgniterType();
+}
+
+IgniterFunction DtcImpl::igniterFunction(int /*igniterFunctionId*/)
+{
+  return IgniterFunction();
+}
+
+LoadType DtcImpl::loadType(int /*loadTypeId*/)
+{
+  return LoadType();
+}
+
+GearType DtcImpl::gearType(int /*gearTypeId*/)
+{
+  return GearType();
+}
+
+int DtcImpl::targetType(int /*targetTypeId*/)
+{
+  return 0;
+}
+
+TargetSubType DtcImpl::targetSubType(int /*targetSubTypeId*/)
+{
+  return TargetSubType();
+}
+
+// Collection getters - stub implementations
+QMap<int, ChargeTypeData> DtcImpl::chargeTypes()
+{
+  return QMap<int, ChargeTypeData>();
+}
+
+QVector<IgniterType> DtcImpl::igniterTypes()
+{
+  return QVector<IgniterType>();
+}
+
+QVector<IgniterFunction> DtcImpl::igniterFunctions()
+{
+  return QVector<IgniterFunction>();
+}
+
+QVector<LoadType> DtcImpl::loadTypes()
+{
+  return QVector<LoadType>();
+}
+
+QVector<GearType> DtcImpl::gearTypes()
+{
+  return QVector<GearType>();
+}
+
+QVector<int> DtcImpl::targetTypes()
+{
+  return QVector<int>();
+}
+
+QVector<TargetSubType> DtcImpl::targetSubTypes()
+{
+  return QVector<TargetSubType>();
+}
+
+QVector<ChargeTypeIgniterTypeIgniterFunction> DtcImpl::chargeTypeIgniterTypeIgniterFunctions()
+{
+  return QVector<ChargeTypeIgniterTypeIgniterFunction>();
+}
+
+QVector<ChargeTypeLoadType> DtcImpl::chargeTypeLoadTypes()
+{
+  return QVector<ChargeTypeLoadType>();
+}
+
+QVector<GearTypeChargeType> DtcImpl::gearTypeChargeTypes()
+{
+  return QVector<GearTypeChargeType>();
+}
+
+QVector<BuildingChargeEffect> DtcImpl::buildingChargeEffects()
+{
+  return QVector<BuildingChargeEffect>();
+}
+
+// isEnabled checks - stub implementations
+bool DtcImpl::isChargeTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isIgniterTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isIgniterFunctionEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isLoadTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isGearTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isTargetTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isTargetSubTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isChargeTypeIgniterTypeIgniterFunctionEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isChargeTypeLoadTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isGearTypeChargeTypeEnabled()
+{
+  return false;
+}
+
+bool DtcImpl::isBuildingChargeEffectEnabled()
+{
+  return false;
+}
+
+// waitForHistoricalData methods - stub implementations
+void DtcImpl::waitForHistoricalDataChargeType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataIgniterType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataIgniterFunction(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataLoadType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataGearType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataTargetType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataTargetSubType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataChargeTypeIgniterTypeIgniterFunction(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataChargeTypeLoadType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataGearTypeChargeType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataBuildingChargeEffect(int /*timeout_ms*/)
+{
+}
+
+// Additional enable methods for pdm_handler.cpp
+void DtcImpl::enableGearType(bool /*enable*/)
+{
+}
+
+void DtcImpl::enableGearTypeChargeType(bool /*enable*/)
+{
+}
+
+void DtcImpl::enableTargetTypeTargetSubType(bool /*enable*/)
+{
+}
+
+void DtcImpl::enableRadioGroup(bool /*enable*/)
+{
+}
+
+void DtcImpl::enableVulnerabilityKind(bool /*enable*/)
+{
+}
+
+void DtcImpl::enableBuildingChargeEffect(bool /*enable*/)
+{
+}
+
+// Additional waitForHistoricalData methods for pdm_handler.cpp
+void DtcImpl::waitForHistoricalDataTargetTypeTargetSubType(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataRadioGroup(int /*timeout_ms*/)
+{
+}
+
+void DtcImpl::waitForHistoricalDataVulnerabilityKind(int /*timeout_ms*/)
+{
+}
+
+// Helper methods
+QJsonObject DtcImpl::propertiesToJson(const std::string & /*properties*/)
+{
+  return QJsonObject();
+}
+
+} // namespace Interface
+} // namespace ProjectDataManagement
@@ -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
@@ -0,0 +1,34 @@
+
+/**
+* Operator Rights definitions
+*/
+
+// warning: this file is generated with command
+// Lts/Common/CodeGen/codegen_simple.py ALL Lts/Services/ProjectDataManagement/pdm_service.xml build/Lts/Services/ProjectDataManagement/
+// at Sun Sep  6 18:00:15 2026
+// it will be overwritten by next run - do not modify!
+
+#pragma once
+
+namespace ProjectDataManagement 
+{
+  static const int Offset = 29; 
+}
+
+namespace OperatorRights
+{
+enum Charges
+{
+  ChargeVisibilityEdit = 0x1d010001,
+};
+
+enum Groups_ProjectDataManagement
+{
+  GroupChargeVisibility = 0x1d010000,
+};
+
+enum Plugins_ProjectDataManagement
+{
+  PluginCharges = 0x1d010000,
+};
+}  // namespace OperatorRights
@@ -0,0 +1,7 @@
+// Stub file for pdm_translation.h - used when BUILD_GRANTLEE=OFF
+#ifndef PDM_TRANSLATION_H
+#define PDM_TRANSLATION_H
+
+// Minimal stub - actual translation generated by codegen when BUILD_GRANTLEE=ON
+
+#endif // PDM_TRANSLATION_H
@@ -0,0 +1,15 @@
+// Stub file for pdm_types.h - used when BUILD_GRANTLEE=OFF
+#ifndef PDM_TYPES_H
+#define PDM_TYPES_H
+
+#include <cstdint>
+
+namespace ProjectDataManagement {
+
+enum class EventType : std::int32_t {
+    Unknown = 0
+};
+
+} // namespace ProjectDataManagement
+
+#endif // PDM_TYPES_H
@@ -0,0 +1,41 @@
+/**
+  * @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 <QObject>
+
+namespace Database
+{
+// Stub struct for RecSnapshot
+struct RecSnapshot
+{
+  qint64 id = 0;
+  // Add other fields as needed
+};
+} // namespace Database
+
+namespace RecordingManagement
+{
+
+/**
+ * @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 QObject
+{
+  Q_OBJECT
+public:
+  explicit DatabaseInterfaceImpl(QObject *parent = nullptr) : QObject(parent) {}
+  virtual ~DatabaseInterfaceImpl() = default;
+
+  // Virtual methods that can be overridden by custom implementations
+  virtual bool removeNewerEqual(const Database::RecSnapshot &data) = 0;
+};
+
+} // namespace RecordingManagement
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ReportManagement/rep_dtc.h>
@@ -0,0 +1,4 @@
+#pragma once
+
+// STUB-HEADER: Include generated file from build directory
+#include <Lts/Proxies/ScenarioManagement/scm_dtc.h>
Author	SHA1	Message	Date
berrux-dev	9c1ac7cbef	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).	2026-09-27 07:33:29 +02:00
berrux-dev	36f077bce4	Emit record_replay fromQVariant for plain enums; document PPM MOC exclusion	2026-09-26 00:49:47 +02:00
berrux-dev	a410019553	Complete Qt6/rtiddsgen migration of residual Lts service sources	2026-09-25 20:23:37 +02:00
torsten	c664611b80	Migrates non-ArcGIS built successfully (tbc)	2026-09-24 16:49:49 +02:00
berrux-dev	e748e82c84	Fix allowed_signers principal format for SSH signature verification Line 2 (services side) used a bare key line, which the allowed_signers parser rejects; prefix it with the signer principal like line 1 so git verify-commit matches the key.	2026-09-24 10:51:34 +02:00
torstenandCopilot	4223ca2ff5	Qt6 Migration: Update stub headers to include generated files - Updated all include//_dtc.h stub headers to include generated files from build4/Lts/Proxies/*/ directories - Changed ParticipantManagement stub headers to use generated files - Updated ProjectDataManagement pdm_enums.hpp to include generated file - Updated Buildings bld_dtc.h to include generated file - Created BUILD_STATUS_REPORT.md documenting current build state Migration Status: - DDS core libraries: ✅ Building successfully (6 libraries) - Proxies module code: ✅ Migration complete - Services modules: ⚠️ Pre-existing errors blocking full build - ParticipantManagement: Type definition mismatches - InfrastructureManagement: Struct/member mismatches - ProjectDataManagement: DTC implementation errors These Services errors are unrelated to Qt6 migration work and require separate fixes. Once resolved, Proxies module will build automatically. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-24 10:43:10 +02:00
berrux-dev	5381c65fee	Merge feature/qt6-migration-basis-modules-services into feature/qt6-migration-basis-modules Resolves 17 conflicts against legacy Qt5 semantics; validates with BUILD_RTI=ON BUILD_GRANTLEE=ON.	2026-09-24 10:10:25 +02:00
torstenandCopilot	b6a97c39e5	Fix KDReports detection and add codification support for viewer-only builds - Update FindKDReports.cmake to always use CONFIG mode first with explicit search paths - Add --codification/--no-codification CLI options to new_docker_build.sh - Add BUILD_CODIFICATION to cmake invocation and Docker environment variables - Fix BUILD_GROUP5=ON when BUILD_VIEWER_ONLY is enabled - Exclude LtsFileDialog from viewer-only builds (depends on Group 4 services) - Fix KDReports git clone to use default branch (removed non-existent branch) - Add KDReports symlink creation to Dockerfile for include path compatibility Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-23 17:37:56 +02:00
torstenandCopilot	fd3e5e8380	Add --build-viewer-only option to skip Groups 1-4 and build Viewer targets only - Add --build-viewer-only command-line option to argument parsing - Add BUILD_VIEWER_ONLY environment variable handling - Add conditional build logic to skip Groups 1-4 when enabled - Update usage() documentation with new option - Enable CTest when --build-viewer-only is specified - Allows bypassing pre-existing Group 3/4 build errors Tested: Successfully skips Groups 1-4 and builds Group 5 Viewer targets Validated: situationMapCommon, advancedSymbologyXML, LtsDataView build without errors No Qt5→Qt6 deprecation warnings in Viewer module targets Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-23 13:36:37 +02:00
torsten	ed9fc51e7a	Migrates ./Lts/Viewer successfully to Qt6	2026-09-23 10:14:59 +02:00
torstenandCopilot	cdb8c754e9	Add GROUP5 build configuration and CTest registration for Viewer module - Add GROUP5_TARGETS array with 7 Viewer module targets to new_docker_build.sh - Add BUILD_GRANTLEE support throughout build script (help, env vars, cmake invocation) - Fix duplicate BUILD_GROUP4 default in container script section - Register LtsDataViewTest with CTest in LtsDataView/CMakeLists.txt - Register LtsFileDialogTest with CTest in LtsFileDialog/CMakeLists.txt - Update help text to document --group5/--no-group5 and --grantlee/--no-grantlee options - Set BUILD_GROUP5=OFF and BUILD_GRANTLEE=ON as defaults Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-22 16:50:49 +02:00
torsten	0997dcba79	Fixes merge conflicts, but leaves out-of-DDS-scope build errors (tbc)	2026-09-21 17:04:53 +00:00
torstenandCopilot	f6292cc244	Add DDS migration completion report - Documents successful build of all 6 DDS core libraries - Records all fixes applied (readAlive wrappers, logger namespace, setSubscriberCallback) - Notes pre-existing errors in ParticipantManagement/ProjectDataManagement (unrelated to DDS) - Provides verification command for DDS-only builds Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-21 16:07:07 +00:00
torstenandCopilot	ef20ac3d95	Add LTS/Proxies migration report - Documents merge conflict resolution for 8 files - Summarizes LTS module migration status (DTC, FTS, CodeGen) - Documents Proxies integration test results (92% pass rate) - Details build system changes in new_docker_build.sh - Lists known limitations and next steps Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-21 14:08:29 +00:00
torstenandCopilot	ab29b7b2d5	Merge origin/feature/migrate-and-test-DDS-targets into feature/qt6-migration-basis-modules Resolve merge conflicts between Qt6 migration basis modules and DDS test/target migration: - codegen_simple.py: Keep Qt6 includes (generic_dtc_impl.h, service header) - svc_ftc_impl.cpp.grantlee: Adopt DDS branch conditional logic ({% if ft.isCoreFt %}) - generic_dtc.h/.impl.h (include/ and Lts/): Keep Qt6 full-path includes, explicit wrapper methods for consistency - connext.h: Add logger initialization for Requester/Replier (DDS branch enhancement) - new_docker_build.sh: - Add GROUP4_TARGETS for DDS tests - Smart DOCKER_IMAGE selection (prebuilt vs ubuntu:26.04) - Add BUILD_TESTING=ON to cmake - Add Group 4 (DDS Tests) build step Strategy: Preserve Qt6 migration decisions while incorporating DDS test/target changes. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>	2026-09-21 14:07:42 +00:00
torsten	7cd3e43959	Adds ktexttemplate as apt package to new_docker_build.sh and builds successfully	2026-09-21 15:43:39 +02:00
torsten	4bf53db7fa	Adds modules ./Z and ./Lts/Proxies production ready	2026-09-21 13:36:17 +00:00
torsten	a1914cb7d9	Adds succesfull lts/proxies migration & testsuite	2026-09-19 09:18:18 +00:00