Continues migration with DDS, Common

Lts/Common/LtsUtils/LtsUtilsGui/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+# Created by Mike Wille, SLSE, 2016-09-19
+#
+
+ADD_SUBDIRECTORY(LtsUtilsGuiDds)
+ADD_SUBDIRECTORY(ConnectDialog)
+ADD_SUBDIRECTORY(StyleManager)

Lts/Common/LtsUtils/LtsUtilsGui/ConnectDialog/CMakeLists.txt

@@ -0,0 +1,28 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+# Created by Mike Wille, SLSE, 2016-05-12
+#
+
+SET(srcs
+  connect_dialog.h
+  connect_dialog.cpp
+  connect_dialog_nt.h
+  connect_dialog_nt.cpp
+)
+
+NGL_WRAP_UI(srcs
+  connect_dialog.ui
+)
+
+NGL_ADD_LIBRARY2(WS LtsUtilsGuiConnectDialog SHARED ${srcs})
+NGL_TARGET_INCLUDE_DIRECTORIES(LtsUtilsGuiConnectDialog
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+NGL_TARGET_LINK_LIBRARIES(LtsUtilsGuiConnectDialog
+  Qt5::Widgets
+  LtsWidgets
+)

Lts/Common/LtsUtils/LtsUtilsGui/ConnectDialog/connect_dialog.cpp

@@ -0,0 +1,73 @@
+
+
+
+#include "connect_dialog.h"
+#include "ui_connect_dialog.h"
+
+#include <stdlib.h>
+
+
+namespace LtsUtils
+{
+int ConnectingDialog::s_waitForHistoricalDataWaitTime = 10000;
+
+
+void ConnectingDialog::reset()
+{
+  m_ui->label->setText(QStringLiteral("<font color='orange'>%1</font>").arg(tr("Connecting to %1 on %2 ...").arg(m_serviceName, m_exerciseName)));
+}
+
+
+void ConnectingDialog::setup()
+{
+  m_ui = new Ui::ConnectingDialog;
+  m_ui->setupUi(this);
+  reset();
+  setMinimumSize(sizeHint());
+  connect(m_ui->pbRetry, &QPushButton::clicked,
+          this, [this]()
+  {
+    m_ui->pbRetry->setEnabled(false);
+    m_ui->pbIgnore->setEnabled(false);
+
+    reset();
+    emit signalStopLoop();
+  });
+
+  connect(m_ui->pbIgnore, &QPushButton::clicked,
+          this, [this]()
+  {
+    m_ui->pbIgnore->setEnabled(false);
+    m_ui->pbRetry->setEnabled(false);
+    m_ui->pbIgnore->setText(tr("continuing.."));
+
+    deleteLater();
+    return; 
+
+    
+
+
+
+
+    
+  });
+}
+
+
+ConnectingDialog::~ConnectingDialog()
+{
+  delete m_ui;
+}
+
+
+void ConnectingDialog::failed()
+{
+  m_ui->label->setText(QStringLiteral("<font color='red'>%1</font>").arg(tr("Could not connect to %1 on %2 !").arg(m_serviceName, m_exerciseName)));
+
+  m_ui->pbRetry->setEnabled(true);
+  m_ui->pbIgnore->setEnabled(true);
+
+  raise();
+}
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/ConnectDialog/connect_dialog.h

@@ -0,0 +1,82 @@
+
+
+
+#pragma once
+
+#include <ConnectDialog/ltsutilsguiconnectdialog_export.h>
+#include <LtsWidgets/lts_frameless_dialog.h>
+
+#include <QWidget>
+#include <QTimer>
+
+#include <functional>
+
+
+namespace Ui
+{
+class ConnectingDialog;
+}
+
+namespace LtsUtils
+{
+
+class LTSUTILSGUICONNECTDIALOG_EXPORT ConnectingDialog : public LtsWidgets::LtsFramelessDialog
+{
+  Q_OBJECT
+
+public:
+  static int s_waitForHistoricalDataWaitTime;
+
+  template <typename DtcType, typename WaitForHistoricalDataFunction>
+  explicit ConnectingDialog(DtcType dtc,
+                            WaitForHistoricalDataFunction waitForHistoricalDataFunction,
+                            const QString &serviceName,
+                            const QString &exerciseName,
+                            QWidget *parent = nullptr)
+  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
+  , m_serviceName(serviceName)
+  , m_exerciseName(exerciseName)
+  , m_ui(nullptr)
+  {
+    setWindowTitle(tr("Connecting .."));
+    setup();
+    show();
+
+    while (true)
+    {
+      if ((dtc.get()->*waitForHistoricalDataFunction)(s_waitForHistoricalDataWaitTime))
+      {
+        deleteLater();
+        return; 
+      }
+
+      if (s_waitForHistoricalDataWaitTime >= 999999)
+      { 
+        deleteLater();
+        return;
+      }
+      else
+      {
+        failed();
+      }
+    }
+  }
+
+  ~ConnectingDialog();
+
+  void failed();
+
+private:
+  QString m_serviceName;
+  QString m_exerciseName;
+  Ui::ConnectingDialog *m_ui;
+
+  void reset();
+  void setup();
+
+signals:
+  void signalStopLoop();
+
+};
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/ConnectDialog/connect_dialog.ui

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ConnectingDialog</class>
+ <widget class="QWidget" name="ConnectingDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>260</width>
+    <height>200</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>260</width>
+    <height>200</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Login</string>
+  </property>
+  <layout class="QVBoxLayout" name="mainLayout" stretch="0,0">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string/>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+     <property name="wordWrap">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QPushButton" name="pbRetry">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Retry</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="pbIgnore">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="text">
+        <string>Ignore</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

Lts/Common/LtsUtils/LtsUtilsGui/ConnectDialog/connect_dialog_nt.cpp

@@ -0,0 +1,157 @@
+
+
+
+#include "connect_dialog.h"
+#include "connect_dialog_nt.h"
+#include "ui_connect_dialog.h"
+
+#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
+#include <QRandomGenerator>
+#endif
+
+
+namespace LtsUtils
+{
+
+
+ConnectingDialogNT::ConnectingDialogNT(const std::function<bool(int)> &checkFn,
+                                       const QString &serviceName,
+                                       const QString &exerciseName,
+                                       QWidget *parent)
+  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
+  , m_serviceName(serviceName)
+  , m_exerciseName(exerciseName)
+  , m_checkFn(checkFn)
+  , m_go(false)
+  , m_autoRetryTimer(new QTimer(this))
+  , m_ui(new Ui::ConnectingDialog )
+{
+  m_ui->setupUi(this);
+
+  m_autoRetryTimer->setInterval(1000);
+  connect(m_autoRetryTimer, &QTimer::timeout,
+          this, [this]()
+  {
+    if (m_autoRetryTick < 1)
+    {
+      slotRetry();
+      return;
+    }
+
+    m_ui->pbRetry->setText(QStringLiteral("%1 [%2]").arg(tr("Retry")).arg(m_autoRetryTick));
+    m_autoRetryTick--;
+  });
+
+  reset();
+  setMinimumSize(sizeHint());
+  connect(m_ui->pbRetry, &QPushButton::clicked,
+          this, &ConnectingDialogNT::slotRetry);
+
+  connect(m_ui->pbIgnore, &QPushButton::clicked,
+          this, [this]()
+  {
+    m_ui->pbIgnore->setEnabled(false);
+    m_ui->pbRetry->setEnabled(false);
+    m_ui->pbIgnore->setText(tr("continuing.."));
+
+    emit signalFailed();
+    deleteLater();
+    return; 
+
+    
+
+
+
+
+    
+  });
+
+  show();
+
+  connect(this, &ConnectingDialogNT::signalGo,
+          this, &ConnectingDialogNT::slotGo, Qt::QueuedConnection);
+
+  m_go = true;
+  m_ui->pbRetry->setEnabled(false);
+}
+
+
+int ConnectingDialogNT::random(int min, int max)
+{
+#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
+  return QRandomGenerator::global()->bounded(min, max);
+#else
+  return (qrand() % (((max + 1) - min) + min));
+#endif
+}
+
+
+
+bool ConnectingDialogNT::event(QEvent *event)
+{
+  bool result = LtsWidgets::LtsFramelessDialog::event(event);
+
+  if (event->type() == QEvent::Paint && m_go)
+  {
+    m_go = false;
+    QTimer::singleShot(0, this, &ConnectingDialogNT::signalGo);
+  }
+
+  return result;
+}
+
+
+void ConnectingDialogNT::slotRetry()
+{
+  m_autoRetryTimer->stop();
+
+  m_ui->pbRetry->setText(tr("Retry"));
+  m_ui->pbRetry->setEnabled(false);
+  m_ui->pbIgnore->setEnabled(false);
+
+  reset();
+  QTimer::singleShot(1, this, &ConnectingDialogNT::slotGo); 
+}
+
+
+void ConnectingDialogNT::slotGo()
+{
+  
+  if (m_checkFn(ConnectingDialog::s_waitForHistoricalDataWaitTime))
+  {
+    emit signalSuccess();
+    deleteLater();
+    return; 
+  }
+
+  
+  failed();
+}
+
+
+void ConnectingDialogNT::reset()
+{
+  m_ui->label->setText(QStringLiteral("<font color='orange'>%1</font>").arg(tr("Connecting to %1 on %2 ...").arg(m_serviceName, m_exerciseName)));
+}
+
+
+ConnectingDialogNT::~ConnectingDialogNT()
+{
+  delete m_ui;
+}
+
+
+void ConnectingDialogNT::failed()
+{
+  m_ui->label->setText(QStringLiteral("<font color='red'>%1</font>").arg(tr("Could not connect to %1 on %2 !").arg(m_serviceName, m_exerciseName)));
+
+  m_ui->pbRetry->setEnabled(true);
+  m_ui->pbIgnore->setEnabled(true);
+
+  m_autoRetryTick = random(5, 20); 
+  m_autoRetryTimer->start();
+
+  raise();
+}
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/ConnectDialog/connect_dialog_nt.h

@@ -0,0 +1,63 @@
+
+
+
+#pragma once
+
+#include <ConnectDialog/ltsutilsguiconnectdialog_export.h>
+#include <LtsWidgets/lts_frameless_dialog.h>
+
+#include <functional>
+
+
+class QTimer;
+
+namespace Ui
+{
+class ConnectingDialog;
+}
+
+namespace LtsUtils
+{
+
+class LTSUTILSGUICONNECTDIALOG_EXPORT ConnectingDialogNT : public LtsWidgets::LtsFramelessDialog
+{
+  Q_OBJECT
+
+public:
+  
+
+  explicit ConnectingDialogNT(const std::function<bool(int)> &checkFn,
+                              const QString &serviceName,
+                              const QString &exerciseName,
+                              QWidget *parent);
+  ~ConnectingDialogNT();
+
+
+  void failed();
+
+private slots:
+  void slotGo();
+  void slotRetry();
+
+signals:
+  void signalGo();
+  void signalFailed();
+  void signalSuccess();
+
+private:
+  QString m_serviceName;
+  QString m_exerciseName;
+  std::function<bool(int)> m_checkFn;
+  bool m_go;
+
+  QTimer *m_autoRetryTimer;
+  int m_autoRetryTick { 0 };
+
+  Ui::ConnectingDialog *m_ui;
+
+  int random(int min, int max);
+  bool event(QEvent *event) override;
+  void reset();
+};
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/CMakeLists.txt

@@ -0,0 +1,49 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+# Created by Mike Wille, SLSE, 2016-09-19
+#
+
+SET(SRCS
+  dds_vector_to_pixmap.cpp
+  dds_vector_to_pixmap.h
+  request_helper.cpp
+  request_helper.h
+)
+
+NGL_ADD_LIBRARY2(WS LtsUtilsGuiDds SHARED ${SRCS})
+NGL_TARGET_INCLUDE_DIRECTORIES(LtsUtilsGuiDds
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+)
+NGL_TARGET_LINK_LIBRARIES(LtsUtilsGuiDds
+  PRIVATE
+    LtsUtilsCoreHeaderOnly
+    LtsWidgets
+    Qt5::Gui
+    Qt5::Widgets
+    Qt5::Svg
+  PUBLIC
+    Qt5::Core
+    ddscore
+)
+NGL_TARGET_COMPILE_DEFINITIONS(LtsUtilsGuiDds
+  PUBLIC
+    REQUEST_HELPER_WITH_GUI
+)
+
+
+NGL_ADD_LIBRARY2(AAR HLA  SV LtsUtilsDds SHARED request_helper.cpp request_helper.h)
+NGL_TARGET_INCLUDE_DIRECTORIES(LtsUtilsDds
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+)
+NGL_TARGET_LINK_LIBRARIES(LtsUtilsDds
+  PRIVATE
+    LtsUtilsCoreHeaderOnly
+  PUBLIC
+    Qt5::Core
+    ddscore
+)

Lts/Common/LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/dds_vector_to_pixmap.cpp

@@ -0,0 +1,134 @@
+
+
+
+#include <LtsUtilsCore/dds_vector.h>
+#include <LtsUtilsGuiDds/dds_vector_to_pixmap.h>
+
+#include <QBuffer>
+#include <QFile>
+#include <QIcon>
+#include <QImage>
+#include <QPainter>
+#include <QPixmap>
+#include <QSvgRenderer>
+
+
+namespace LtsUtils
+{
+
+QIcon iconFromSvg(const QByteArray &svgData, QSize iconSize)
+{
+  QSvgRenderer renderer(svgData);
+  QPixmap p(iconSize);
+  p.fill(Qt::transparent);
+  QPainter painter(&p);
+  renderer.render(&painter);
+  painter.end();
+
+  return {p};
+}
+
+QIcon iconFromSvg(const QString &svgFilename, QSize iconSize)
+{
+  QFile f(svgFilename);
+  if (!f.open(QIODevice::ReadOnly))
+    return {};
+  return iconFromSvg(f.readAll(), iconSize);
+}
+
+QPixmap pixmapFromIcon(const QIcon &icon, QSize iconSize)
+{
+  return icon.pixmap(iconSize).scaled(100, 100, Qt::AspectRatioMode::IgnoreAspectRatio);
+}
+
+QPixmap pixmapFromSvg(const QString &svgFilename, QSize iconSize)
+{
+  return pixmapFromIcon(iconFromSvg(svgFilename, iconSize), iconSize);
+}
+
+QPixmap getPixmap(const std::vector<uint8_t> &data)
+{
+  if (data.size() == 0)
+    return QPixmap();
+  
+  return getPixmap(QByteArray(reinterpret_cast<const char*>(&data.at(0)), data.size()));
+}
+
+QPixmap getPixmap(const QByteArray &data)
+{
+  return QPixmap::fromImage(QImage::fromData(data));
+}
+
+QImage getImage(const std::vector<uint8_t> &data)
+{
+  if (data.size() == 0)
+    return QImage();
+  
+  return getImage(QByteArray(reinterpret_cast<const char*>(&data.at(0)), data.size()));
+}
+
+QImage getImage(const QByteArray &data)
+{
+  return QImage::fromData(data);
+}
+
+static inline void setIf(bool *boolPtr, bool val)
+{
+  if (boolPtr)
+    *boolPtr = val;
+}
+
+std::vector<uint8_t> fromPixmap(const QPixmap &pixmap, bool *bIsPng)
+{
+  QBuffer buf;
+  buf.open(QIODevice::WriteOnly);
+  pixmap.save(&buf, "PNG");
+  buf.close();
+  QByteArray ba = buf.buffer();
+
+  setIf(bIsPng, true);
+  
+  if (ba.size() > 10240 && !pixmap.hasAlpha() && !pixmap.hasAlphaChannel())
+  {
+    QBuffer buf2;
+    buf2.open(QIODevice::WriteOnly);
+    pixmap.save(&buf2, "JPG");
+    buf2.close();
+    if (buf2.buffer().size() < buf.buffer().size())
+    {
+      setIf(bIsPng, false);
+      ba = buf2.buffer();
+    }
+  }
+
+  return convert<std::vector<uint8_t>>(ba);
+}
+
+std::vector<uint8_t> fromImage(const QImage &image, bool *bIsPng)
+{
+  QBuffer buf;
+  buf.open(QIODevice::WriteOnly);
+  image.save(&buf, "PNG");
+  buf.close();
+  QByteArray ba = buf.buffer();
+
+  
+  setIf(bIsPng, true);
+  if ((ba.size() > 10240 && !image.hasAlphaChannel()) ||
+      ba.size() > 1024 * 1024)
+  {
+    QBuffer buf2;
+    buf2.open(QIODevice::WriteOnly);
+    image.save(&buf2, "JPG");
+    buf2.close();
+    if (buf2.buffer().size() < buf.buffer().size())
+    {
+      setIf(bIsPng, false);
+      ba = buf2.buffer();
+    }
+  }
+
+  return convert<std::vector<uint8_t>>(ba);
+}
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/dds_vector_to_pixmap.h

@@ -0,0 +1,33 @@
+
+
+
+#pragma once
+
+#include <LtsUtilsCore/ltsutilscore_export.h>
+
+#include <QSize>
+#include <QString>
+
+#include <cstdint>
+#include <vector>
+
+class QByteArray;
+class QPixmap;
+class QImage;
+class QIcon;
+
+namespace LtsUtils
+{
+
+LTSUTILSCORE_EXPORT QPixmap getPixmap(const std::vector<uint8_t> &data);
+LTSUTILSCORE_EXPORT QPixmap getPixmap(const QByteArray &data);
+LTSUTILSCORE_EXPORT QImage getImage(const std::vector<uint8_t> &data);
+LTSUTILSCORE_EXPORT QImage getImage(const QByteArray &data);
+LTSUTILSCORE_EXPORT QIcon iconFromSvg(const QByteArray &svgData, QSize iconSize = QSize(100, 100));
+LTSUTILSCORE_EXPORT QIcon iconFromSvg(const QString &svgFilename, QSize iconSize = QSize(100, 100));
+LTSUTILSCORE_EXPORT QPixmap pixmapFromIcon(const QIcon &icon, QSize iconSize = QSize(100, 100));
+LTSUTILSCORE_EXPORT QPixmap pixmapFromSvg(const QString &svgFilename, QSize iconSize = QSize(100, 100));
+LTSUTILSCORE_EXPORT std::vector<uint8_t> fromPixmap(const QPixmap &pixmap, bool *bIsPng = nullptr);
+LTSUTILSCORE_EXPORT std::vector<uint8_t> fromImage(const QImage &image, bool *bIsPng = nullptr);
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.cpp

@@ -0,0 +1,276 @@
+
+
+
+#include "request_helper.h"
+
+#ifdef REQUEST_HELPER_WITH_GUI
+#include <LtsWidgets/lts_global_wait_dialog.h>
+#include <LtsWidgets/lts_message_dialog.h>
+#include <QWidget>
+#endif
+
+
+#include <QEventLoop>
+#include <QTimer>
+#include <memory>
+#include <QJsonDocument>
+#include <QJsonObject>
+
+#define DEBUG
+
+
+namespace LtsUtils
+{
+bool RequestHelper::s_debug = false;
+
+RequestHelper::RequestHelper(QObject *parent, bool quiet,
+                             
+                             const std::function<void (void)> &success,
+                             const std::function<void (void)> &failure)
+  : QObject(parent)
+  , m_failed(false)
+  , m_repliedId(-1)
+  , m_quiet(quiet)
+  , m_blockingCall(true)
+  , m_successFn(success)
+  , m_failureFn(failure)
+{
+  connect(this, &RequestHelper::signalSuccess, this, m_successFn, Qt::QueuedConnection);
+  connect(this, &RequestHelper::signalFailed, this, m_failureFn, Qt::QueuedConnection);
+
+  if (s_debug)
+  {
+    QTimer *t = new QTimer(this);
+    t->setInterval(2000);
+    t->setSingleShot(true); 
+    connect(this, &RequestHelper::signalNextRequest, t, static_cast<void (QTimer::*)(void)>(&QTimer::start));
+    connect(t, &QTimer::timeout, this, &RequestHelper::slotNextRequest, Qt::QueuedConnection);
+  }
+  else
+  {
+    connect(this, &RequestHelper::signalNextRequest,
+            this, &RequestHelper::slotNextRequest,
+            Qt::QueuedConnection
+            
+);
+  }
+}
+
+
+void RequestHelper::addRequest(const std::function<int64_t()> &requestFunction,
+                               const std::function<void(const Core::FunctionReply &baseReply)> &baseReplyHandler)
+{
+  m_requestFunctions.append(RequestFunctionContainer(requestFunction, baseReplyHandler));
+}
+
+bool RequestHelper::requestReply(const Core::FunctionReply &baseReply)
+{
+  const Core::FunctionReplyObject fro(baseReply.id(),
+                                      baseReply.errorString(),
+                                      baseReply.errorParams());
+  return _requestReply(fro, &baseReply);
+}
+
+bool RequestHelper::requestReply(const Core::FunctionReplyObject &replyObject)
+{
+  return _requestReply(replyObject, nullptr);
+}
+
+
+bool RequestHelper::_requestReply(const Core::FunctionReplyObject &fro, const Core::FunctionReply *baseReply)
+{
+  m_errorString = fro.translated();
+
+#ifdef REQUEST_HELPER_WITH_GUI
+  if (fro.error())
+  {
+
+    if (!m_quiet)
+    {
+      if (m_blockingCall)
+      {
+        LtsWidgets::LtsMessageDialog::showMessage(qobject_cast<QWidget *>(parent()),
+                                                  m_errorString,
+                                                  tr("Request failed"));
+      }
+      else 
+      {
+        new LtsWidgets::LtsMessageDialogNew(qobject_cast<QWidget *>(parent()),
+                                            m_errorString,
+                                            tr("Request failed"));
+      }
+    }
+  }
+#endif
+
+  m_repliedId = fro.id(); 
+
+  if (m_singleRequestCustomFunctionReply != nullptr)
+  {
+    if (baseReply)
+      m_singleRequestCustomFunctionReply(*baseReply);
+    else
+      m_singleRequestCustomFunctionReply(Core::FunctionReply(fro.id(), fro.str(), fro.args(), fro.additionalInfo()));
+  }
+
+  if (fro.error())
+  {
+    failure();
+    return false;
+  }
+
+  emit signalNextRequest();
+  return true;
+}
+
+
+bool RequestHelper::startSingleRequest(const std::function<int64_t()> &requestFunction,
+                                       const std::function<void(const Core::FunctionReply &baseReply)> &baseReplyHandler)
+{
+  addRequest(requestFunction, baseReplyHandler);
+  return startRequests();
+}
+
+
+void RequestHelper::failure()
+{
+  m_failed = true;
+  emit signalFailed();
+  done();
+}
+
+
+void RequestHelper::done()
+{
+#ifdef REQUEST_HELPER_WITH_GUI
+  if (!m_quiet)
+    LtsWidgets::LtsGlobalWaitDialog::getInstance()->done();
+#endif
+
+  m_requestFunctions.clear();
+  m_singleRequestCustomFunctionReply = nullptr;
+
+  if (m_blockingCall)
+    emit signalQuitLoop(); 
+
+  m_blockingCall = true;
+
+  if (!m_blockingCall)
+    deleteLater(); 
+}
+
+
+void RequestHelper::slotNextRequest()
+{
+  if (m_requestFunctions.isEmpty())
+  {
+    if (!m_blockingCall)
+      emit signalSuccess();
+
+    done(); 
+
+    return;
+  }
+
+  const RequestFunctionContainer rfc = m_requestFunctions.takeFirst();
+  m_singleRequestCustomFunctionReply = rfc.second;
+
+  int64_t result = rfc.first(); 
+
+  if (result == 0) 
+  {
+#ifdef REQUEST_HELPER_WITH_GUI
+    if (!m_quiet)
+    {
+      if (m_blockingCall)
+      {
+        LtsWidgets::LtsMessageDialog::showMessage(qobject_cast<QWidget *>(parent()),
+                                                  tr("Request failed")); 
+      }
+      else 
+      {
+        connect(new LtsWidgets::LtsMessageDialogNew(qobject_cast<QWidget *>(parent()),
+                                                    tr("Request failed")), &LtsWidgets::LtsMessageDialogNew::destroyed,
+                this, [this]()
+        {
+          failure();
+        });
+
+        return;
+      }
+    }
+#endif
+    failure();
+  }
+}
+
+
+void RequestHelper::startSingleBackgroundRequest(const std::function<int64_t()> &requestFunction,
+                                                 const std::function<void (const Core::FunctionReply &)> &baseReplyHandler)
+{
+  m_blockingCall = false;
+  startSingleRequest(requestFunction, baseReplyHandler);
+}
+
+
+void RequestHelper::startBackgroundRequests()
+{
+  m_blockingCall = false;
+  startRequests();
+}
+
+
+void RequestHelper::setCustomWaitMessage(const QString &customWaitMessage)
+{
+  m_customWaitMessage = (customWaitMessage + QStringLiteral(" ..."));
+}
+
+
+bool RequestHelper::startRequests()
+{
+  if (m_requestFunctions.isEmpty())
+  {
+#ifdef LTS_DEBUG
+    qWarning("RequestHelper: started request helper without requests!");
+#endif
+    return true;
+  }
+
+  m_failed = false;
+
+#ifdef REQUEST_HELPER_WITH_GUI
+  if (!m_quiet)
+    LtsWidgets::LtsGlobalWaitDialog::getInstance()->wait(m_customWaitMessage);
+  m_customWaitMessage.clear();
+#endif
+
+  m_errorString.clear();
+  m_repliedId = -1;
+
+  if (s_debug)
+  {
+    QTimer *t = new QTimer(this);
+    t->setInterval(2000);
+    connect(t, &QTimer::timeout, this, &RequestHelper::slotNextRequest, Qt::QueuedConnection);
+    connect(t, &QTimer::timeout, t, &QTimer::deleteLater);
+    t->start();
+  }
+  else
+  {
+    slotNextRequest();
+
+    if (m_blockingCall)
+    {
+      QEventLoop loop;
+      connect(this, &RequestHelper::signalQuitLoop,
+              &loop, &QEventLoop::quit,
+              Qt::QueuedConnection);
+      loop.exec();
+    }
+  }
+
+
+  return (!m_failed); 
+}
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h

@@ -0,0 +1,123 @@
+
+
+
+#pragma once
+
+#ifdef REQUEST_HELPER_WITH_GUI
+#include <LtsUtilsGuiDds/ltsutilsguidds_export.h>
+#define LTSUTILSGUIDDS_INTERNAL_EXPORT LTSUTILSGUIDDS_EXPORT
+#else
+#include <LtsUtilsGuiDds/ltsutilsdds_export.h>
+#define LTSUTILSGUIDDS_INTERNAL_EXPORT LTSUTILSDDS_EXPORT
+#endif
+
+#include <DDS/Core/function_reply_object.h>
+#include <DDS/Core/core.hpp> 
+
+#include <QObject>
+#include <QVector>
+#include <QPair>
+#include <functional>
+
+
+namespace LtsUtils
+{
+
+template<typename T>
+dds::core::optional<T> toOptional(T inVal)
+{
+  return inVal != T() ? dds::core::optional<T>(inVal) : dds::core::optional<T>();
+}
+
+template<typename T>
+dds::core::optional<T> optional()
+{
+  return dds::core::optional<T>();
+}
+
+
+class LTSUTILSGUIDDS_INTERNAL_EXPORT RequestHelper : public QObject 
+{
+  Q_OBJECT
+
+public:
+  static bool s_debug;
+
+  explicit RequestHelper(QObject *parent = nullptr, bool quiet = false,
+                         
+                         const std::function<void (void)> &success = [](){},
+                         const std::function<void (void)> &failure = [](){});
+  ~RequestHelper() = default;
+
+  bool quiet() const { return m_quiet; }
+  void setQuiet(bool quiet) { m_quiet = quiet; }
+  void addRequest(const std::function<int64_t()> &requestFunction,
+                  const std::function<void(const Core::FunctionReply &baseReply)> &baseReplyHandler = nullptr);
+  bool startRequests(); 
+
+  
+  bool startSingleRequest(const std::function<int64_t(void)> &requestFunction,
+                          const std::function<void(const Core::FunctionReply &baseReply)> &baseReplyHandler = nullptr 
+  );
+
+  
+  
+
+  void startSingleBackgroundRequest(const std::function<int64_t()> &requestFunction,
+                                    const std::function<void(const Core::FunctionReply &baseReply)> &baseReplyHandler = nullptr);
+  
+
+  void startBackgroundRequests(); 
+
+  bool requestReply(const Core::FunctionReply &baseReply); 
+  bool requestReply(const Core::FunctionReplyObject &replyObject);
+
+  
+
+  bool hasRequests() const { return !m_requestFunctions.isEmpty(); }
+
+
+  
+
+  int getRepliedId() const { return m_repliedId; }
+
+  
+
+  QString getErrorString() const { return m_errorString; }
+
+  
+
+  void setCustomWaitMessage(const QString &customWaitMessage);
+
+  bool failed() const { return m_failed; }
+  void failure();
+
+private:
+  using RequestFunctionContainer = QPair<std::function<int64_t()>, std::function<void(const Core::FunctionReply &)>>;
+
+  QVector<RequestFunctionContainer> m_requestFunctions;
+  bool m_failed;
+  int m_repliedId;
+  std::function<void(const Core::FunctionReply &)> m_singleRequestCustomFunctionReply;
+  bool m_quiet;
+  bool m_blockingCall;
+  std::function<void (void)> m_successFn;
+  std::function<void (void)> m_failureFn;
+  QString m_errorString;
+  QString m_customWaitMessage;
+
+  void done();
+  bool _requestReply(const Core::FunctionReplyObject &fro, const Core::FunctionReply *baseReply);
+
+signals:
+  void signalNextRequest();
+  void signalQuitLoop();
+  void signalSuccess();
+  void signalFailed();
+
+private slots:
+  void slotNextRequest();
+
+};
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/StyleManager/CMakeLists.txt

@@ -0,0 +1,22 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+# Created by Mike Wille, NLSE, 2018-02-15
+#
+
+SET(srcs
+  style_manager.h
+  style_manager.cpp
+)
+
+NGL_ADD_LIBRARY2(WS LtsUtilsGuiStyleManager SHARED ${srcs})
+NGL_TARGET_INCLUDE_DIRECTORIES(LtsUtilsGuiStyleManager
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+NGL_TARGET_LINK_LIBRARIES(LtsUtilsGuiStyleManager
+  Qt5::Core
+  LtsPluginLoader
+)

Lts/Common/LtsUtils/LtsUtilsGui/StyleManager/style_manager.cpp

@@ -0,0 +1,114 @@
+
+
+
+#include "style_manager.h"
+
+#include <LtsPluginManager/lts_plugin_loader.h>
+#include <PluginInterfaces/style_plugin_interface.h>
+
+#include <QPluginLoader>
+#include <QDebug>
+
+
+namespace LtsUtils
+{
+
+struct StyleManagerHandler
+{
+  StyleManager styleManager;
+};
+Q_GLOBAL_STATIC(StyleManagerHandler, s_styleManagerHandler)
+
+
+StyleManager *StyleManager::getInstance()
+{
+  return &s_styleManagerHandler->styleManager;
+}
+
+bool StyleManager::loadStyle(const QString &stylePluginName, bool highDpi)
+{
+  if (m_currentStylePluginLoader != nullptr) 
+  {
+    
+
+    QObject *pluginInstance = m_currentStylePluginLoader->instance();
+    StylePlugin::Plugin *sp = qobject_cast<StylePlugin::Plugin *>(pluginInstance);
+
+    if (sp == nullptr)
+    {
+      qWarning() << "StyleManager::loadStyle: could not unload style plugin - wrong type ("
+                 << pluginInstance->metaObject()->className() << ") - new style not loaded";
+      return false;
+    }
+
+    sp->unloadStyle();
+
+    
+
+
+
+
+
+
+
+    m_currentStylePluginLoader = nullptr;
+  }
+
+
+  
+  LtsPluginManager::LtsPluginLoader *pluginLoader = LtsPluginManager::LtsPluginLoader::getInstance();
+
+  QPluginLoader *stylePluginLoader = nullptr;
+  int pluginsLoaded = 0;
+
+  std::function<bool(const LtsPluginManager::PluginInstance &pi)> loadPluginFn = [&stylePluginLoader, &pluginsLoaded]
+                                                                                 (const LtsPluginManager::PluginInstance &pi)
+  {
+    stylePluginLoader = pi.pluginLoader;
+    pluginsLoaded++;
+    return true;
+  };
+
+  if (!pluginLoader->loadPlugins(LtsPluginManager::PluginType::STYLE, loadPluginFn, QStringList() << stylePluginName))
+  {
+    qWarning() << "StyleManager::loadStyle: Error loading Style Plugin - using default Qt style";
+    return false;
+  }
+
+  if (pluginsLoaded == 0)
+  {
+    qWarning() << "StyleManager::loadStyle: Could not find Style Plugin" << stylePluginName << "- using default Qt style";
+    return false;
+  }
+
+  if (pluginsLoaded > 1)
+  {
+    qWarning() << "StyleManager::loadStyle: Style Plugin" << stylePluginName << " is ambiguous - using default Qt style";
+    return false;
+  }
+
+  if (stylePluginLoader == nullptr)
+  {
+    qWarning() << "StyleManager::loadStyle: No Style Plugin loader available - using default Qt style";
+    return false;
+  }
+
+  StylePlugin::Plugin *sp = qobject_cast<StylePlugin::Plugin *>(stylePluginLoader->instance());
+
+  if (sp == nullptr)
+  {
+    qWarning() << "StyleManager::loadStyle: could not load style plugin - wrong type ("
+               << stylePluginLoader->instance()->metaObject()->className() << ") - new style not loaded";
+    return false;
+  }
+
+  sp->loadStyle(highDpi);
+
+  m_currentStylePluginLoader = stylePluginLoader;
+  m_stylePluginName = stylePluginName;
+  emit signalStyleChanged(stylePluginName);
+
+  return true;
+}
+
+} 

Lts/Common/LtsUtils/LtsUtilsGui/StyleManager/style_manager.h

@@ -0,0 +1,36 @@
+
+
+
+#pragma once
+
+#include <StyleManager/ltsutilsguistylemanager_export.h>
+#include <QObject>
+
+
+class QPluginLoader;
+
+
+namespace LtsUtils
+{
+class LTSUTILSGUISTYLEMANAGER_EXPORT StyleManager : public QObject
+{
+  Q_OBJECT
+  using QObject::QObject;
+  ~StyleManager() = default;
+public:
+  static StyleManager *getInstance();
+
+  bool loadStyle(const QString &stylePluginName, bool highDpi = false);
+  const QString &currentStyleName() const { return m_stylePluginName; }
+
+private:
+  friend struct StyleManagerHandler;
+
+  QPluginLoader *m_currentStylePluginLoader = nullptr;
+  QString m_stylePluginName;
+
+signals:
+  void signalStyleChanged(const QString &stylePluginName);
+
+};
+}