Adds further migration results and moves generated tests in

qt6-after/qt6-migrated-legatus/include/AdlerJson/json_dispatcher.h

@@ -12,7 +12,7 @@
 #include <QHash>
 #include <QObject>
 #include <QVector>
-#include <QWebSocket>
+#include <QtWebSockets/QWebSocket>
 #include <Core/core_types.h> // tr_lts
 #include <TrainingAreaBase/tab_plugin_interface.h>
 // #include "logger.h"

qt6-after/qt6-migrated-legatus/include/AdlerJson/ws_handler.h

@@ -4,7 +4,7 @@
 #include "logger.h"
 
 #include <TrainingAreaBase/training_area_telegrams.h>
-#include <QWebSocketServer>
+#include <QtWebSockets/QWebSocketServer>
 #include <QObject>
 #include <memory>
 

qt6-after/qt6-migrated-legatus/include/AudioVideoManagement/ava_types.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 <QMetaType>
+#include "svcavmcommon_export.h"
+#include <QString>
+#include <QStringList>
+#include <QVector>
+#include <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)

qt6-after/qt6-migrated-legatus/include/AudioVideoManagement/avm_enums_stub.hpp

@@ -0,0 +1,128 @@
+// Stub enums for AudioVideoManagement when BUILD_RTI is OFF
+// These enums are normally generated from avm_enums.idl by RTI DDS tools
+// This file provides minimal definitions for building without RTI
+
+#ifndef AVM_ENUMS_STUB_HPP
+#define AVM_ENUMS_STUB_HPP
+
+#include <QString>
+
+namespace AudioVideoManagement {
+
+// RcOperatingMode enum wrapper with inner_enum typedef and underlying() method
+struct RcOperatingMode {
+    enum Type {
+        FixedFreqEncNone = 0,
+        FixedFreqEncHwKr = 1,
+        FixedFreqEncHwKrKl = 2,
+        AkwEncNone = 3,
+        AkwEncEccm = 4,
+        SIMPLEX = 5,
+        HALFDUPLEX = 6,
+        DUPLEX = 7
+    };
+    using inner_enum = Type;
+    
+    Type value;
+    constexpr RcOperatingMode(Type v = FixedFreqEncNone) : value(v) {}
+    constexpr operator Type() const { return value; }
+    int underlying() const { return static_cast<int>(value); }
+    
+    static constexpr Type FixedFreqEncNone_v = FixedFreqEncNone;
+    static constexpr Type FixedFreqEncHwKr_v = FixedFreqEncHwKr;
+    static constexpr Type FixedFreqEncHwKrKl_v = FixedFreqEncHwKrKl;
+    static constexpr Type AkwEncNone_v = AkwEncNone;
+    static constexpr Type AkwEncEccm_v = AkwEncEccm;
+    static constexpr Type SIMPLEX_v = SIMPLEX;
+    static constexpr Type HALFDUPLEX_v = HALFDUPLEX;
+    static constexpr Type DUPLEX_v = DUPLEX;
+};
+
+// FrequencyBand enum wrapper with inner_enum typedef and underlying() method
+struct FrequencyBand {
+    enum Type {
+        Undefined = 0,
+        HF = 1,
+        VHF = 2,
+        UHF = 3,
+        REL = 4
+    };
+    using inner_enum = Type;
+    
+    Type value;
+    constexpr FrequencyBand(Type v = Undefined) : value(v) {}
+    constexpr operator Type() const { return value; }
+    int underlying() const { return static_cast<int>(value); }
+    
+    static constexpr Type Undefined_v = Undefined;
+    static constexpr Type HF_v = HF;
+    static constexpr Type VHF_v = VHF;
+    static constexpr Type UHF_v = UHF;
+    static constexpr Type REL_v = REL;
+};
+
+// FrequencyBand_def namespace for legacy code compatibility
+namespace FrequencyBand_def {
+    constexpr int HF = 1;
+    constexpr int UHF = 3;
+    constexpr int VHF = 2;
+    constexpr int REL = 4;
+}
+
+// RcOperatingMode_def namespace for legacy code compatibility
+namespace RcOperatingMode_def {
+    constexpr int FixedFreqEncNone = 0;
+    constexpr int FixedFreqEncHwKr = 1;
+    constexpr int FixedFreqEncHwKrKl = 2;
+    constexpr int AkwEncNone = 3;
+    constexpr int AkwEncEccm = 4;
+    constexpr int SIMPLEX = 5;
+    constexpr int HALFDUPLEX = 6;
+    constexpr int DUPLEX = 7;
+}
+
+// ModulationType enum wrapper with inner_enum typedef and underlying() method
+struct ModulationType {
+    enum Type {
+        AM = 0,
+        FM = 1
+    };
+    using inner_enum = Type;
+    
+    Type value;
+    constexpr ModulationType(Type v = AM) : value(v) {}
+    constexpr operator Type() const { return value; }
+    int underlying() const { return static_cast<int>(value); }
+};
+
+// ChannelSpacingHF enum wrapper with inner_enum typedef and underlying() method
+struct ChannelSpacingHF {
+    enum Type {
+        CS_100_Hz = 0
+    };
+    using inner_enum = Type;
+    
+    Type value;
+    constexpr ChannelSpacingHF(Type v = CS_100_Hz) : value(v) {}
+    constexpr operator Type() const { return value; }
+    int underlying() const { return static_cast<int>(value); }
+};
+
+// ChannelSpacing enum wrapper with inner_enum typedef and underlying() method
+struct ChannelSpacing {
+    enum Type {
+        CS_25_00_kHz = 0,
+        CS_12_50_kHz = 1,
+        CS_8_33_kHz = 2
+    };
+    using inner_enum = Type;
+    
+    Type value;
+    constexpr ChannelSpacing(Type v = CS_25_00_kHz) : value(v) {}
+    constexpr operator Type() const { return value; }
+    int underlying() const { return static_cast<int>(value); }
+};
+
+} // namespace AudioVideoManagement
+
+#endif // AVM_ENUMS_STUB_HPP

qt6-after/qt6-migrated-legatus/include/AudioVideoManagement/avm_export.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

qt6-after/qt6-migrated-legatus/include/AudioVideoManagement/avm_translation.h

@@ -0,0 +1,78 @@
+/**
+ * @file avm_translation.h
+ * @brief Translation functions for AudioVideoManagement enums
+ * 
+ * This file provides toString() functions for AVM enums used in CNR frequency planning.
+ * Stub implementation for non-RTI builds.
+ */
+
+#ifndef AVM_TRANSLATION_H
+#define AVM_TRANSLATION_H
+
+#include <QString>
+#include "avm_enums_stub.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

qt6-after/qt6-migrated-legatus/include/AudioVideoManagement/svcavmcommon_export.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 */

qt6-after/qt6-migrated-legatus/include/Core/core_types.h

@@ -99,4 +99,46 @@ private:
   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

qt6-after/qt6-migrated-legatus/include/ExerciseEventManagement/eem.hpp

@@ -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

qt6-after/qt6-migrated-legatus/include/ExerciseEventManagement/eem_export.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

qt6-after/qt6-migrated-legatus/include/ExerciseEventManagement/eem_types.h

@@ -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 <QString>
+#include <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

qt6-after/qt6-migrated-legatus/include/LtsScriptTimeline/ltsscripttimeline_export.h

@@ -0,0 +1,12 @@
+// STUB HEADER - Generated during Qt6 migration
+// This file compensates for missing ltsscripttimeline_export.h when LtsScriptTimeline is not built
+// Original would be generated by CMake GENERATE_EXPORT_HEADER for LtsScriptTimeline library
+
+#ifndef LTSSCRIPTTIMELINE_EXPORT_H
+#define LTSSCRIPTTIMELINE_EXPORT_H
+
+// Stub export macros for BUILD_RTI=OFF or when LtsScriptTimeline is not built
+#define LTSSCRIPTTIMELINE_EXPORT
+#define LTSSCRIPTTIMELINE_NO_EXPORT
+
+#endif // LTSSCRIPTTIMELINE_EXPORT_H

qt6-after/qt6-migrated-legatus/include/LtsSession/ltssession_export.h

@@ -0,0 +1,11 @@
+#ifndef LTSSESSION_EXPORT_H
+#define LTSSESSION_EXPORT_H
+
+// Stub export header for LtsSession when built without RTI
+// This file is generated by CMake when building with RTI
+// For non-RTI builds, we provide this stub
+
+#define LTSSESSION_EXPORT
+#define LTSSESSION_NO_EXPORT
+
+#endif // LTSSESSION_EXPORT_H

qt6-after/qt6-migrated-legatus/include/LtsUtilsGuiDds/ltsutilsguidds_export.h

@@ -0,0 +1,17 @@
+// Stub export header for LtsUtilsGuiDds
+// Generated by CMake when BUILD_RTI=ON, stub for BUILD_RTI=OFF
+
+#ifndef LTSUTILSGUIDDS_EXPORT_H
+#define LTSUTILSGUIDDS_EXPORT_H
+
+// When BUILD_RTI is OFF, this library is not built
+// Stub header allows compilation of dependent code
+
+#define LTSUTILSGUIDDS_EXPORT
+#define LTSUTILSGUIDDS_NO_EXPORT
+
+// dds_vector_to_pixmap.h uses LTSUTILSCORE_EXPORT (from LtsUtilsCore)
+// Define it here for compatibility when LtsUtilsGuiDds is used standalone
+#define LTSUTILSCORE_EXPORT
+
+#endif // LTSUTILSGUIDDS_EXPORT_H

qt6-after/qt6-migrated-legatus/include/NGLLogger/ngllogger_export.h

@@ -0,0 +1,11 @@
+#ifndef NGLLOGGER_EXPORT_H
+#define NGLLOGGER_EXPORT_H
+
+// Stub export header for NGLLogger when built without RTI
+// This file is generated by CMake when building with RTI
+// For non-RTI builds, we provide this stub
+
+#define NGLLOGGER_EXPORT
+#define NGLLOGGER_NO_EXPORT
+
+#endif // NGLLOGGER_EXPORT_H

qt6-after/qt6-migrated-legatus/include/OperatorManagement/opm_ftc.h

@@ -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 <QString>
+#include <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

qt6-after/qt6-migrated-legatus/include/Services/PresentationManagement/pre_ftc.h

@@ -0,0 +1,59 @@
+/**
+ * @file pre_ftc.h
+ * @brief Stub-Header für PresentationManagement 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 wenn BUILD_RTI=OFF.
+ */
+
+#pragma once
+
+#include <functional>
+#include <memory>
+
+namespace PresentationManagement
+{
+
+// Forward declarations
+struct Presentation;
+struct PresentationContent;
+struct GetPresentationContentReply;
+
+namespace Interface
+{
+
+/**
+ * @brief Ftc - Filter Topic Client für Presentation Management
+ *
+ * Stub-Implementation für DDS-generierten FTC.
+ * Gibt nullptr zurück da keine echte DDS-Verbindung verfügbar.
+ */
+class Ftc
+{
+  public:
+    using ModifyTypeReplyHandler = std::function<void(bool success)>;
+
+    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
+    }
+
+    // PresentationModify Reply Handler
+    virtual void presentationModifyReply(ModifyTypeReplyHandler /*handler*/) = 0;
+
+    // PresentationRemove Reply Handler
+    virtual void presentationRemoveReply(ModifyTypeReplyHandler /*handler*/) = 0;
+
+    // GetPresentationContent Reply Handler
+    virtual void getPresentationContentReply(const GetPresentationContentReply& /*reply*/) = 0;
+};
+
+} // namespace Interface
+} // namespace PresentationManagement

qt6-after/qt6-migrated-legatus/include/TopicEditorBase/topiceditorbase_export.h

@@ -0,0 +1,11 @@
+#ifndef TOPICEDITORBASE_EXPORT_H
+#define TOPICEDITORBASE_EXPORT_H
+
+// Stub export header for TopicEditorBase when built without RTI
+// This file is generated by CMake when building with RTI
+// For non-RTI builds, we provide this stub
+
+#define TOPICEDITORBASE_EXPORT
+#define TOPICEDITORBASE_NO_EXPORT
+
+#endif // TOPICEDITORBASE_EXPORT_H