Initial commit

Lts/Plugins/AudioVideoManagement/Gui/AVMenuEdit/avm_available_streams_model.cpp

@@ -0,0 +1,323 @@
+/**
+  * @RDE_HEADER@
+  * Radio TreeModel
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "avm_available_streams_model.h"
+#include <AudioVideoManagement/stream_name_mapping.h>
+#include <InfrastructureManagement/ism.hpp>
+#include <nglwidgets/ngltreeitem.h>
+
+#include <QSet>
+#include <QMimeData>
+#include <QCollator>
+
+namespace
+{
+
+bool isMountingPointOfInterest(const InfrastructureManagement::StructureElement &se, bool isAudio)
+{
+  if (se.structureElementTypeId() != InfrastructureManagement::StructureElementType::MountingPoint)
+    return false;
+
+  // Cameras are relevant for both, audio and video
+  // The problem for audio here is that we cannot know yet whether later
+  // there will be a camera mounted that is capable of audio.
+  if (se.mountingPointTypeId() == InfrastructureManagement::MountingPointType::IndoorCamera ||
+      se.mountingPointTypeId() == InfrastructureManagement::MountingPointType::OutdoorCamera)
+    return true;
+
+  if (isAudio && se.mountingPointTypeId() == InfrastructureManagement::MountingPointType::AnnouncementUnit)
+    return true;
+
+  return false;
+}
+
+} // anonymous namespace
+
+
+
+namespace AudioVideoManagement
+{
+const QString AvailableStreamsModel::s_MimeType = QStringLiteral("AvailStreamsModel/DragDrop");
+
+
+
+struct sorter
+{
+  bool operator()(const StreamModelData &i, const StreamModelData &j)
+  {
+    QCollator col;
+    col.setNumericMode(true);
+    return col.compare(j.name, i.name) > 0 ;
+  }
+} sortStuff;
+
+
+AvailableStreamsModel::AvailableStreamsModel(const std::shared_ptr<Interface::Dtc> &avmDtc,
+                                             const std::shared_ptr<InfrastructureManagement::Interface::Dtc> &ismDtc,
+                                             LtsSession::LtsSession *session,
+                                             StreamNameMapping *streamNameMapping,
+                                             QObject *parent,
+                                             bool isAudio)
+  : NGLTreeModel(parent, new NGLTreeItem(QVariant(), QIcon()), {tr("Available Streams")})
+, m_isAudio(isAudio)
+, m_avmDtc(avmDtc)
+, m_ismDtc(ismDtc)
+, m_session(session)
+, m_streamNameMapping(streamNameMapping)
+, m_logger(getLogger("AvailableStreamsModel"))
+{
+  Q_ASSERT(ismDtc);
+  Q_ASSERT(streamNameMapping);
+  qRegisterMetaTypeStreamOperators<StreamModelData>("StreamModelData");
+  qRegisterMetaType<StreamModelData>("StreamModelData");
+
+  setMimeType(s_MimeType);
+  connect(m_ismDtc.get(), &InfrastructureManagement::Interface::Dtc::mainStructureElementChanged,
+          this, [ this]()
+  {
+    initModel();
+  });
+
+  connect(m_streamNameMapping, &StreamNameMapping::changed,
+          this, [ this]()
+  {
+    initModel();
+  });
+
+  if (!m_isAudio)
+  {
+    connect(m_avmDtc.get(), &AudioVideoManagement::Interface::Dtc::videoTeamChanged,
+            this, [ this]()
+    {
+      initModel();
+    });
+  }
+  initModel();
+}
+
+QVariant AvailableStreamsModel::data(const QModelIndex &index, int role) const
+{
+  if (!index.isValid())
+    return QVariant();
+
+  NGLTreeItem *item = privateData(index);
+  if (!item->data().canConvert<StreamModelData>())
+    return QVariant();
+
+  const StreamModelData availStream = item->data().value<StreamModelData>();
+
+  switch (role)
+  {
+  case Qt::DisplayRole:
+  {
+    switch (index.column())
+    {
+    case 0 :
+      return availStream.name;
+    default:
+      return QStringLiteral("??");
+    }
+    break;
+  }
+  case Qt::DecorationRole:
+  {
+    switch (index.column())
+    {
+    case 0:
+    {
+      static const QIcon folder(QStringLiteral("icon:evaluation_folder.svg"));
+      static const QIcon camera(QStringLiteral("icon:camera_control.svg"));
+      return availStream.isGroup ? folder : camera;
+    }
+    default:
+      break;
+    }
+    break;
+  }
+  default:
+    break;
+  } // switch
+  return NGLTreeModel::data(index, role);
+}
+
+
+Qt::ItemFlags AvailableStreamsModel::flags(const QModelIndex &index) const
+{
+  Qt::ItemFlags defaultFlags = NGLTreeModel::flags(index);
+  NGLTreeItem *item = privateData(index);
+
+  if (item == m_rootItem)
+    return  defaultFlags;
+
+  return  Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | defaultFlags;
+}
+
+
+QMimeData *AvailableStreamsModel::mimeData(const QModelIndexList &indexes) const
+{
+  // Use display role (textual name of stream) for identification when dropping mimeData
+  QMimeData *pData = NGLTreeModel::mimeData(indexes);
+  pData->setText(data(indexes[0]).toString());
+  return pData;
+}
+
+
+bool AvailableStreamsModel::dropMimeData(const QMimeData *data, Qt::DropAction action,
+                                         int row, int column, const QModelIndex &parent)
+{
+  INFO_LOG(m_logger) << "dropMimeData: action = " << action
+                     << ", row = " << row
+                     << ", parent: valid = " << parent.isValid();
+
+  if (action == Qt::IgnoreAction)
+    return true;
+
+  if (!data->hasFormat(s_MimeType))
+    return false;
+
+  if ((action != Qt::MoveAction) && (action != Qt::CopyAction))
+    return false;
+
+  return NGLTreeModel::dropMimeData(data, action, row, column, parent);
+}
+
+
+void AvailableStreamsModel::initModel()
+{
+  beginResetModel();
+  INFO_LOG(m_logger) << "initModel";
+  // build tree
+  // Ignore NOT installed streams
+  m_rootItem->removeAllChildren();
+  // group to bundle streams
+  StreamModelData availStream;
+  availStream.id = 0;
+  availStream.name = tr("New group");
+  availStream.parentId = -1;
+  availStream.isGroup = true;
+
+  QVariant data;
+  data.setValue(availStream);
+  m_rootItem->appendChild(new NGLTreeItem(data, QIcon()));
+
+  std::vector<StreamModelData> toAddIndoor;
+  std::vector<StreamModelData> toAddOutdoor;
+
+  std::vector<StreamModelData> toAddMvs;
+
+
+  const auto &mountedAssets = m_ismDtc->mountingPointAssets();
+  const auto &buildings = m_ismDtc->mainStructureElements();
+  for (const auto &building : buildings)
+  {
+    for (const auto &mountingPoint : building.elements())
+    {
+      if (!isMountingPointOfInterest(mountingPoint, m_isAudio))
+        continue;
+
+      //check for mounted
+      bool isMounted = false;
+      for (const auto &mountedAsset : mountedAssets)
+      {
+        if (mountedAsset.structureElementId() == mountingPoint.id())
+        {
+          isMounted = true;
+          break;
+        }
+      }
+
+      if (!isMounted)
+        continue;
+      StreamModelData   item;
+      item.name = m_streamNameMapping->displayName(mountingPoint.id());
+      item.mountingPointId = mountingPoint.id();
+      item.isGroup = false;
+      // What about id and parentId?
+
+      if (mountingPoint.mountingPointTypeId() == InfrastructureManagement::MountingPointType::IndoorCamera)
+        toAddIndoor.push_back(item);
+      else
+        toAddOutdoor.push_back(item);
+      //  m_rootItem->appendChild(new NGLTreeItem(data, QIcon()));
+    }
+  }
+
+
+  //add MVS in video list
+  if (!m_isAudio)
+  {
+    const auto &mvsStreams = m_avmDtc->videoTeams();
+    for (const auto &videoTeam : mvsStreams)
+    {
+      if (videoTeam.exerciseId() != m_session->exerciseId())
+        continue;
+      DEBUG_LOG(m_logger) << "add new videoteam" << videoTeam;
+      StreamModelData item;
+      item.name = QString::fromStdString(videoTeam.streamName().c_str());
+      item.mountingPointId = -1 * videoTeam.id(); // negative id for mvs
+      item.isGroup = false;
+
+      //  data.setValue(item);
+      toAddMvs.push_back(item);
+      //m_rootItem->appendChild(new NGLTreeItem(data, QIcon()));
+    }
+
+  }
+
+  //sort
+
+  // using object as comp
+  std::sort(toAddOutdoor.begin(), toAddOutdoor.end(), sortStuff);
+  for (const auto &item : toAddOutdoor)
+  {
+    data.setValue(item);
+    m_rootItem->appendChild(new NGLTreeItem(data, QIcon()));
+  }
+
+  std::sort(toAddIndoor.begin(), toAddIndoor.end(), sortStuff);
+  for (const auto &item : toAddIndoor)
+  {
+    data.setValue(item);
+    m_rootItem->appendChild(new NGLTreeItem(data, QIcon()));
+  }
+
+  std::sort(toAddMvs.begin(), toAddMvs.end(), sortStuff);
+  for (const auto &item : toAddMvs)
+  {
+    data.setValue(item);
+    m_rootItem->appendChild(new NGLTreeItem(data, QIcon()));
+  }
+  endResetModel();
+}
+
+StreamModelData StreamModelData::createFromServiceItem(const AvMenuEntry &entry, StreamNameMapping *streamNameMapping, const QMap<int, VideoTeam> &videoTeamList)
+{
+  StreamModelData   data;
+  data.id = entry.id();
+  data.parentId = entry.parentId();
+  data.isGroup = entry.isGroup();
+  if (entry.isGroup())
+    data.name = QString::fromStdString(entry.name().get());
+  else
+  {
+    if (entry.mountingPointId().is_set() && (entry.mountingPointId().get() > 0))
+    {
+      data.mountingPointId = entry.mountingPointId().get();
+      data.name = streamNameMapping->displayName(entry.mountingPointId().get());
+    }
+    else
+    {
+      data.mountingPointId = entry.mountingPointId().get();
+      data.name = QString::fromStdString(videoTeamList.value(entry.mountingPointId().get() * -1).streamName());
+    }
+  }
+
+  return data;
+}
+
+} // Namespace AudioVideoManagement