Adds initial intermediate qt6 porting state

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/CMakeLists.txt

@@ -0,0 +1,40 @@
+#
+# @RDE_HEADER@
+# $Id$
+# $HeadURL$
+# $Author$
+# Created by Christian Fröbel, NLSE, 2018-04-19
+#
+
+set(SRCS
+  avs_app.cpp
+  avs_app.h
+  playback_app.cpp
+  playback_app.h
+  plugin_settings.cpp
+  plugin_settings.h
+  project_settings.cpp
+  project_settings.h
+  stream_list_result.h
+  stream_list_result.cpp
+)
+
+#
+# Shared Lib used by several Plugins.
+# It has a dependency to LtsMultiMonitor and thus cannot be integrated into svcAvmCommon
+# which needs to be built on SV, too.
+#
+NGL_ADD_LIBRARY2(WS AvmShared SHARED ${SRCS})
+NGL_TARGET_LINK_LIBRARIES(AvmShared
+  PUBLIC
+    Qt5::Core
+    svcAvmCommon
+    Boost::boost
+  PRIVATE
+    LtsMultiMonitor
+    LtsUtilsSettings
+    Qt5::Gui
+    nglsettings
+    ngltools
+)
+NGL_INSTALL_TARGET(AvmShared)

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/avs_app.cpp

@@ -0,0 +1,210 @@
+
+
+
+#include "avs_app.h"
+#include <AudioVideoManagement/ava_control.h>
+#include <LtsMultiMonitor/lts_dummy_widget.h>
+#include <LtsMultiMonitor/lts_multi_monitor.h>
+#include <QGuiApplication>
+#include <QScreen>
+#include <QPoint>
+#include <QtGlobal>
+
+
+
+
+
+#include <QDebug>
+
+
+
+
+namespace
+{
+
+QScreen* screenAt(const QPoint &pos)
+{
+  const auto   screens = QGuiApplication::screens();
+  for (auto screen : screens)
+    if (screen->geometry().contains(pos))
+      return screen;
+  return QGuiApplication::primaryScreen();
+}
+
+QRect screenGeometryOf(const QPoint &pos)
+{
+  
+  QScreen   *screen = screenAt(pos);
+  return screen->geometry();
+}
+
+} 
+
+
+
+namespace AudioVideoManagement
+{
+
+const QString AvsApp::ALL_STREAMS = QStringLiteral("*");
+
+AvsApp::AvsApp(const QString &dialogId, AvaControl *avaControl)
+  : m_dialogId(dialogId)
+  , m_avaControl(avaControl)
+  , m_visible(false)
+{
+  Q_ASSERT(avaControl);
+}
+
+AvsApp::~AvsApp()
+{
+  if (m_screenPlacementHelper)
+    m_screenPlacementHelper->deleteLater();
+}
+
+void AvsApp::show(const QVector<QWidget *> irreplacableWidgets)
+{
+  qWarning() << "AvsApp::show";
+  Q_ASSERT(!m_presetGeometry);
+
+  if (m_screenPlacementHelper)
+    return;
+
+  m_screenPlacementHelper = new LtsMultiMonitor::FullscreenVideoDummyWidget;
+
+  connect(m_screenPlacementHelper, &LtsMultiMonitor::FullscreenVideoDummyWidget::signalWidgetPlaced, this, &AvsApp::onWidgetPlaced);
+  connect(m_screenPlacementHelper, &LtsMultiMonitor::FullscreenVideoDummyWidget::signalHideVideo, this, &AvsApp::onHideVideo);
+  connect(m_screenPlacementHelper, &LtsMultiMonitor::FullscreenVideoDummyWidget::signalShowVideo, this, &AvsApp::onShowVideo);
+  connect(m_screenPlacementHelper, &LtsMultiMonitor::FullscreenVideoDummyWidget::destroyed, this, &AvsApp::onPlacementHelperDestroyed);
+
+  LtsMultiMonitor::LtsMultiMonitor::getInstance()->selectScreen(m_screenPlacementHelper, nullptr, false, true , irreplacableWidgets);
+}
+
+void AvsApp::show(const QRect &geometry)
+{
+  qWarning() << "AvsApp::show (direct)";
+  showAvsDialog(geometry);
+  m_presetGeometry = geometry;
+}
+
+void AvsApp::hide(bool andClose)
+{
+  qWarning() << "AvsApp::hide";
+
+  hideAvsDialog();
+
+  if (m_presetGeometry)
+  {
+    m_presetGeometry.reset();
+    qWarning() << "AvsApp::hide (with preset geo)";
+
+  }
+
+  
+  
+  if (andClose && m_screenPlacementHelper != nullptr)
+    m_screenPlacementHelper->deleteLater();
+}
+
+bool AvsApp::isVisible() const
+{
+  return m_visible;
+}
+
+bool AvsApp::isActive() const
+{
+  return isVisible() || (m_screenPlacementHelper != nullptr);
+}
+
+void AvsApp::releaseStreams()
+{
+
+  m_avaControl->releaseStream(m_dialogId, ALL_STREAMS);
+}
+
+
+
+void AvsApp::onWidgetPlaced(const QRect &geometry)
+{
+  
+  
+  
+  
+
+  qWarning() << "AvsApp::onWidgetPlaced";
+
+  if (strcmp(PROJECTBUILD,"ahtc") == 0 || strcmp(PROJECTBUILD,"qatarmout") == 0 )
+  {
+    showAvsDialog(geometry);
+  }
+  else
+  {
+    QRect screenGeometry = geometry;
+    if (!geometry.isNull())
+      screenGeometry = screenGeometryOf(geometry.topLeft());
+
+    showAvsDialog(screenGeometry);
+  }
+
+}
+
+void AvsApp::onHideVideo()
+{
+  hideAndPauseAvsDialog();
+}
+
+void AvsApp::onShowVideo()
+{
+  showAndResumeAvsDialog();
+}
+
+void AvsApp::onPlacementHelperDestroyed()
+{
+  qWarning() << "AvsApp::onPlacementHelperDestroyed()";
+
+  if (static_cast<LtsMultiMonitor::FullscreenVideoDummyWidget *>(sender()) != m_screenPlacementHelper)
+    return;
+
+  Q_ASSERT(m_screenPlacementHelper);
+  Q_ASSERT(!m_presetGeometry);
+  m_screenPlacementHelper = nullptr;
+  hideAvsDialog();
+}
+
+void AvsApp::showAvsDialog(const QRect &geometry)
+{
+  qWarning() << "AvsApp::showAvsDialog";
+
+  if (geometry.isNull())
+    m_avaControl->setVideoDialogProfile(m_dialogId, AvaVisibility::Visible); 
+  else
+    m_avaControl->setVideoDialogGeometry(m_dialogId, geometry); 
+
+  m_visible = true;
+  emit signalVisible();
+}
+
+void AvsApp::hideAvsDialog()
+{
+  qWarning() << "AvsApp::hideAvsDialog()";
+  
+  
+  releaseStreams();
+  m_avaControl->setVideoDialogProfile(m_dialogId, AvaVisibility::Hidden);
+  m_visible = false;
+}
+
+void AvsApp::hideAndPauseAvsDialog()
+{
+  m_visible = false;
+  m_avaControl->setVideoDialogProfile(m_dialogId, AvaVisibility::Hidden);
+  emit signalPause();
+}
+
+void AvsApp::showAndResumeAvsDialog()
+{
+  m_visible = true;
+  emit signalResume();
+  emit signalVisible();
+}
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/avs_app.h

@@ -0,0 +1,66 @@
+
+
+
+#pragma once
+
+#include <Plugins/AudioVideoManagement/Shared/avmshared_export.h>
+#include <QObject>
+#include <QRect>
+#include <boost/optional.hpp>
+
+namespace LtsMultiMonitor
+{
+class FullscreenVideoDummyWidget;
+}
+
+namespace AudioVideoManagement
+{
+
+class AvaControl;
+
+
+
+class AVMSHARED_EXPORT AvsApp : public QObject
+{
+  Q_OBJECT
+
+public:
+  AvsApp(const QString &dialogId, AvaControl *avaControl);
+  ~AvsApp() override;
+
+  void show(const QVector<QWidget *> irreplacableWidgets = {});
+  void show(const QRect &geometry);
+  void hide(bool andClose = false);
+  bool isVisible() const;
+  bool isActive() const; 
+
+  
+
+  void releaseStreams();
+
+signals:
+  void signalVisible();
+  void signalPause();
+  void signalResume();
+
+private slots:
+  void onWidgetPlaced(const QRect &geometry);
+  void onPlacementHelperDestroyed();
+  void onHideVideo();
+  void onShowVideo();
+
+private:
+  void showAvsDialog(const QRect &geometry);
+  void hideAvsDialog();
+  void hideAndPauseAvsDialog();
+  void showAndResumeAvsDialog();
+
+  static const QString               ALL_STREAMS;
+  const QString                      m_dialogId;
+  AvaControl                        *m_avaControl;
+  LtsMultiMonitor::FullscreenVideoDummyWidget   *m_screenPlacementHelper{nullptr};
+  boost::optional<QRect>             m_presetGeometry;
+  bool                               m_visible;
+};
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/playback_app.cpp

@@ -0,0 +1,96 @@
+
+
+
+#include "playback_app.h"
+#include "avs_app.h"
+
+#include <AudioVideoManagement/avs_dialog.h>
+#include <QtGlobal>
+
+
+namespace AudioVideoManagement
+{
+
+PlaybackApp::PlaybackApp(const QString &dialogId, AvaControl *avaControl, AppType appType)
+  : m_dialogId(dialogId)
+  , m_autoHide(appType == AppType::AutoHide)
+{
+  if (appType != AppType::AlwaysHidden)
+  {
+    m_app.reset(new AvsApp(m_dialogId, avaControl));
+    m_objectWrapper = new ObjectWrapper(nullptr);
+    QObject::connect(m_app.get(), &AvsApp::signalVisible,
+                     m_objectWrapper, &ObjectWrapper::signalVisible);
+    QObject::connect(m_app.get(), &AvsApp::signalPause,
+                     m_objectWrapper, &ObjectWrapper::signalPause);
+    QObject::connect(m_app.get(), &AvsApp::signalResume,
+                     m_objectWrapper, &ObjectWrapper::signalResume);
+  }
+}
+
+PlaybackApp::~PlaybackApp()
+{
+  if (m_objectWrapper)
+    m_objectWrapper->deleteLater();
+}
+
+void PlaybackApp::acquire()
+{
+  Q_ASSERT(!m_inUse);
+  if (m_app)
+    m_app->show();
+  m_inUse = true;
+}
+
+void PlaybackApp::setGeometry(const QRect &geometry)
+{
+  Q_ASSERT(m_app);
+  m_app->show(geometry);
+}
+
+void PlaybackApp::acquire(const QRect &geometry)
+{
+  Q_ASSERT(!m_inUse);
+  setGeometry(geometry);
+  m_inUse = true;
+}
+
+void PlaybackApp::release()
+{
+  Q_ASSERT(m_inUse);
+
+  
+  
+  if (m_autoHide)
+    m_app->hide(true ); 
+  else if (m_app)
+    m_app->releaseStreams();
+  m_inUse = false;
+}
+
+void PlaybackApp::hide(bool andClose)
+{
+  Q_ASSERT(m_inUse);
+
+  if (m_app)
+    m_app->hide(andClose);
+}
+
+
+
+
+PlaybackAppHandle::PlaybackAppHandle(PlaybackApp *app)
+  : m_app(app, [] (PlaybackApp *app_) { app_->release(); })
+{
+  Q_ASSERT(app);
+  app->acquire();
+}
+
+PlaybackAppHandle::PlaybackAppHandle(PlaybackApp *app, const QRect &geometry)
+  : m_app(app, [] (PlaybackApp *app_) { app_->release(); })
+{
+  Q_ASSERT(app);
+  app->acquire(geometry);
+}
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/playback_app.h

@@ -0,0 +1,103 @@
+
+
+
+#pragma once
+
+#include <Plugins/AudioVideoManagement/Shared/avmshared_export.h>
+#include <QString>
+#include <QObject>
+#include <memory>
+#include <functional>
+
+class QRect;
+
+namespace AudioVideoManagement
+{
+
+class AvsApp;
+class AvaControl;
+
+
+class AVMSHARED_EXPORT ObjectWrapper : public QObject
+{
+  Q_OBJECT
+public:
+  ObjectWrapper(QObject *parent) : QObject(parent) {}
+
+signals:
+  void signalVisible();
+  void signalPause();
+  void signalResume();
+};
+
+
+
+
+class AVMSHARED_EXPORT PlaybackApp
+{
+public:
+
+  enum class AppType
+  {
+    Normal = 1,   
+    AutoHide,     
+    AlwaysHidden  
+  };
+
+  
+
+  PlaybackApp(const QString &dialogId, AvaControl *avaControl, AppType);
+  virtual ~PlaybackApp();
+
+  ObjectWrapper *objectWrapper() { return m_objectWrapper; }
+  const QString &dialogId() const { return m_dialogId; }
+
+  
+  bool inUse() const { return m_inUse; }
+
+  
+
+  
+  
+
+  void acquire();
+  void acquire(const QRect &geometry);
+  void setGeometry(const QRect &geometry);
+  
+
+  void release();
+
+  void hide(bool andClose);
+
+  
+
+private:
+  const QString             m_dialogId;
+  bool                      m_inUse{false};
+  bool                      m_autoHide;
+  std::unique_ptr<AvsApp>   m_app; 
+  ObjectWrapper *m_objectWrapper { nullptr };
+};
+
+
+
+
+class AVMSHARED_EXPORT PlaybackAppHandle
+{
+public:
+  PlaybackAppHandle() = default;
+  explicit PlaybackAppHandle(PlaybackApp *app);
+  PlaybackAppHandle(PlaybackApp *app, const QRect &geometry);
+
+  operator bool() const { return m_app.get() != nullptr; }
+
+  const QString &dialogId() const { return m_app->dialogId(); }
+  void hide(bool andClose = false) { m_app->hide(andClose); }
+  ObjectWrapper *objectWrapper() { return m_app->objectWrapper(); }
+
+private:
+  using Releaser = std::function<void (PlaybackApp *)>;
+  std::unique_ptr<PlaybackApp, Releaser>   m_app;
+};
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/plugin_settings.cpp

@@ -0,0 +1,87 @@
+
+
+
+#include "plugin_settings.h"
+#include <nglsettings/nglsettings_settings.h>
+#include <nglsettings/nglsettings_connections.h>
+#include <ngltools/ngltools_filesystem.h>
+#include <QtGlobal>
+#include <QSettings>
+
+
+namespace
+{
+
+const QString &AVA_SECTION()
+{
+  static const QString   key = QStringLiteral("AVS_WORKSTATION");
+  return key;
+}
+
+const QString &VD_SECTION()
+{
+  static const QString   key = QStringLiteral("AVS_WORKSTATION_VD");
+  return key;
+}
+
+
+constexpr std::chrono::milliseconds DEFAULT_TIMEOUT(10000);
+constexpr std::chrono::milliseconds DEFAULT_TIMEOUT_VD(60000);  
+
+} 
+
+
+namespace AudioVideoManagement
+{
+
+PluginSettings   *PluginSettings::s_instance = nullptr;
+
+PluginSettings::PluginSettings()
+  : PluginSettings(NGL::findProjectConfigFile())
+{
+  Q_ASSERT(!s_instance);
+  s_instance = this;
+}
+
+PluginSettings::PluginSettings(const QString &pathToConfigFile)
+  : m_settings(new NGL::Settings(pathToConfigFile))
+{
+  NGL::Connections::setIniFile(pathToConfigFile);
+}
+
+PluginSettings::~PluginSettings()
+{
+  s_instance = nullptr;
+}
+
+PluginSettings *PluginSettings::instance()
+{
+  Q_ASSERT(s_instance);
+  return s_instance;
+}
+
+bool PluginSettings::avaKeepAliveEnabled() const
+{
+  static const QString   key = QStringLiteral("%1/KeepAlive").arg(AVA_SECTION());
+  return m_settings->settings()->value(key, true).toBool();
+}
+
+std::chrono::milliseconds PluginSettings::avaTimeout() const
+{
+  static const QString   key = QStringLiteral("%1/Timeout").arg(AVA_SECTION());
+  return std::chrono::milliseconds(m_settings->settings()->value(key, static_cast<unsigned>(DEFAULT_TIMEOUT.count())).toUInt());
+}
+
+bool PluginSettings::vdKeepAliveEnabled() const
+{
+  static const QString   key = QStringLiteral("%1/KeepAlive").arg(VD_SECTION());
+  return m_settings->settings()->value(key, true).toBool();
+}
+
+std::chrono::milliseconds PluginSettings::vdTimeout() const
+{
+  static const QString   key = QStringLiteral("%1/Timeout").arg(VD_SECTION());
+  return std::chrono::milliseconds(m_settings->settings()->value(key, static_cast<unsigned>(DEFAULT_TIMEOUT_VD.count())).toUInt());
+}
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/plugin_settings.h

@@ -0,0 +1,49 @@
+
+
+
+#pragma once
+
+#include <Plugins/AudioVideoManagement/Shared/avmshared_export.h>
+#include <QString>
+#include <memory>
+#include <chrono>
+
+namespace NGL
+{
+class Settings;
+}
+
+
+namespace AudioVideoManagement
+{
+
+
+
+class AVMSHARED_EXPORT PluginSettings
+{
+public:
+  
+  PluginSettings();
+  explicit PluginSettings(const QString &pathToConfigFile);
+  ~PluginSettings();
+  
+  
+
+  static PluginSettings *instance();
+
+  bool avaKeepAliveEnabled() const;
+  std::chrono::milliseconds avaTimeout() const;
+
+  bool vdKeepAliveEnabled() const;
+  std::chrono::milliseconds vdTimeout() const;
+
+  
+  NGL::Settings *settings() const { return m_settings.get(); }
+  
+private:
+  std::unique_ptr<NGL::Settings>   m_settings;
+
+  static PluginSettings           *s_instance; 
+};
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/project_settings.cpp

@@ -0,0 +1,31 @@
+
+
+
+#include "project_settings.h"
+#include <LtsUtilsSettings/settings.h>
+#include <QString>
+#include <QVariant>
+
+namespace
+{
+
+template<typename T>
+T value(const QString &identifier, const T &defaultValue)
+{
+  LtsUtils::ProjectSettings   *settings = LtsUtils::ProjectSettings::getInstance();
+  QVariant   variant = settings->value(QStringLiteral("avm"), identifier, defaultValue);
+  return variant.value<T>();
+}
+
+} 
+
+
+namespace AudioVideoManagement
+{
+
+bool ProjectSettings::isAlwaysRecording()
+{
+  return value(QStringLiteral("recording"), false);
+}
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/project_settings.h

@@ -0,0 +1,19 @@
+
+
+
+#pragma once
+
+#include <Plugins/AudioVideoManagement/Shared/avmshared_export.h>
+
+namespace AudioVideoManagement
+{
+
+
+
+class ProjectSettings
+{
+public:
+  AVMSHARED_EXPORT static bool   isAlwaysRecording();
+};
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/stream_list_result.cpp

@@ -0,0 +1,35 @@
+#include "stream_list_result.h"
+
+#include <QMap>
+
+namespace AudioVideoManagement {
+
+
+StreamListResult::StreamListResult()
+  : QObject(nullptr)
+{
+}
+
+void StreamListResult::onStreamListReceived(const QVector<AvaStream> &streams)
+{
+  QMap<QString, QString> streamInternalNameToDisplayName;
+  for(const auto &stream : streams)
+  {
+    streamInternalNameToDisplayName.insert(stream.toString(), stream.displayName);
+  }
+  emit emitStreamList(streamInternalNameToDisplayName);
+}
+
+
+
+StreamClipsResult::StreamClipsResult()
+  : QObject(nullptr)
+{
+}
+
+void StreamClipsResult::onClipsListReceived(const AvaTimeline &clips)
+{
+  emit emitClipsList(clips);
+}
+
+} 

qt6-after/qt6-migrated-legatus/Lts/Plugins/AudioVideoManagement/Shared/stream_list_result.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <QObject>
+#include <AudioVideoManagement/ava_types.h>
+#include <Plugins/AudioVideoManagement/Shared/avmshared_export.h>
+
+namespace AudioVideoManagement {
+
+
+class AVMSHARED_EXPORT StreamClipsResult : public QObject
+{
+  Q_OBJECT
+public:
+  StreamClipsResult();
+public slots:
+  void onClipsListReceived(const AvaTimeline &clips);
+signals:
+  void emitClipsList(const AvaTimeline &clips);
+
+};
+
+
+class AVMSHARED_EXPORT StreamListResult : public QObject
+{
+  Q_OBJECT
+public:
+  StreamListResult();
+public slots:
+  void onStreamListReceived(const QVector<AvaStream> &streams);
+signals:
+  void emitStreamList(const QMap<QString, QString> &streams);
+
+
+};
+} 
+