Initial commit

Lts/Plugins/SituationMapPlugin/Gui/SituationMap/layers_model.cpp

@@ -0,0 +1,297 @@
+/**
+  * @RDE_HEADER@
+  * PresentationManangement - Script Overview Dialog Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  *
+  * Created by Mike Wille, SLSE, 2017-03-15
+  */
+
+#include "layers_model.h"
+#include <SituationMap/Map/layer_parameter.h>
+
+
+#include <ngltools/ngltools_dtg.h>
+
+
+#include <QIcon>
+
+namespace SituationMap
+{
+
+LayersModel::LayersModel(LtsSession::LtsSession *session, QObject *parent)
+  : QAbstractTableModel(parent)
+  , m_session(session)
+  , m_logger(getLogger("LayersModel"))
+{}
+
+bool LayersModel::initModel(Map *situationMap)
+{
+  beginResetModel();
+  m_vecData.clear();
+  endResetModel();
+
+  const QStringList sl = situationMap->layerFactory().layernames();
+  m_layerDisplayNameFilterList.clear();
+  if(m_session->app() == LtsAppDescriptor::App::OC)
+  {
+    m_layerDisplayNameFilterList << tr("MountingPoints");
+  }
+
+  for (int i = sl.size() - 1; i >= 0; i--)
+  {
+    LayerInfo li;
+    li.index = i;
+    li.layerName = sl.at(i);
+
+    const LayerParameter &lp = situationMap->layerFactory().layerParameter(li.layerName);
+    const LayerType layerType = situationMap->layerFactory().layerType(li.layerName);
+
+    if (lp.displayName.isEmpty())
+      li.displayName = li.layerName;
+    else
+      li.displayName = lp.displayName;
+
+    if(isDisplayNameInFilter(li.displayName))
+    {
+      continue;
+    }
+
+    li.isVisible  = lp.visible;
+    li.layerType  = layerType;
+    li.opacity    = lp.opacity;
+    li.brightness = lp.brightness;
+    li.contrast   = lp.contrast;
+    li.gamma      = lp.gamma;
+
+    insertRow(li);
+  }
+
+  INFO_LOG(m_logger) << "initModel - #layers: " << m_vecData.size();
+  for (const LayerInfo &item : qAsConst(m_vecData))
+    INFO_LOG(m_logger) << "initModel - layers: " << item.layerName;
+
+  return true;
+}
+
+
+
+QVariant LayersModel::data(const QModelIndex &index, int role) const
+{
+  if ((role != Qt::DisplayRole &&
+       role != Qt::DecorationRole &&
+       role != Qt::ForegroundRole &&
+       role != Qt::EditRole &&
+       role != Qt::CheckStateRole &&
+       role != Qt::UserRole) || !index.isValid() || index.row() >= m_vecData.size())
+    return QVariant();
+
+  if (role == Qt::DecorationRole)
+  {
+    if (index.column() == Layer)
+      return QIcon(QLatin1String("icon:layer.svg"));
+    return QVariant();
+  }
+
+  const LayerInfo &li = m_vecData.at(index.row());
+  if (role == Qt::CheckStateRole)
+    return li.isVisible;
+
+  if (role == Qt::UserRole)
+    return int(li.layerType);
+
+  switch (index.column())
+  {
+  case Layer:
+    return li.displayName;
+  case Opacity:
+    return li.opacity;
+  case Brightness:
+    return li.brightness;
+  case Contrast:
+    return li.contrast;
+  case Gamma:
+    return li.gamma;
+  }
+
+  return QVariant();
+}
+
+bool LayersModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+  if (role != Qt::EditRole && role != Qt::CheckStateRole)
+    return false;
+  LayerInfo &li = m_vecData[index.row()];
+
+  if (role == Qt::CheckStateRole && index.column() == Layer)
+  {
+    li.isVisible = !li.isVisible;
+    emit isVisibleChanged(li.layerName, li.isVisible);
+    return true;
+  }
+
+  switch (index.column())
+  {
+  case Layer:
+    return false;
+  case Opacity:
+    li.opacity = value.toInt();
+    break;
+  case Brightness:
+    li.brightness = value.toInt();
+    break;
+  case Contrast:
+    li.contrast = value.toInt();
+    break;
+  case Gamma:
+    li.gamma = value.toInt();
+    break;
+  }
+  emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
+  emit layerDataChanged(li.layerName, value.toInt(), index.column());
+  return true;
+}
+
+Qt::ItemFlags LayersModel::flags(const QModelIndex &index) const
+{
+  auto f = QAbstractTableModel::flags(index);
+  if (!index.isValid() || index.row() >= m_vecData.size())
+    return f;
+
+  const LayerInfo &li = m_vecData.at(index.row());
+  if (index.column() == Layer)
+  {
+    f.setFlag(Qt::ItemIsUserCheckable);
+    return f;
+  }
+
+  f.setFlag(Qt::ItemIsEditable, li.layerType != LayerType::EmergencyCall);
+
+  if (index.column() != Opacity)
+  {
+    if (li.layerType != LayerType::Basemap)
+      f.setFlag(Qt::ItemIsEditable, false);
+  }
+  return f;
+}
+
+
+int LayersModel::rowCount(const QModelIndex &parent) const
+{
+  Q_UNUSED(parent);
+  return m_vecData.size();
+}
+
+int LayersModel::columnCount(const QModelIndex &parent) const
+{
+  Q_UNUSED(parent);
+  return Gamma + 1;
+}
+
+QVariant LayersModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+  if (orientation == Qt::Horizontal
+      && role == Qt::DisplayRole)
+  {
+    Columns col = static_cast<Columns>(section);
+    switch (col)
+    {
+    case Layer:
+      return tr("Layer");
+    case Opacity:
+      return tr("Opacity");
+    case Brightness:
+      return tr("Brightness");
+    case Contrast:
+      return tr("Contrast");
+    case Gamma:
+      return tr("Gamma");
+
+    }
+  }
+
+  return QAbstractTableModel::headerData(section, orientation, role);
+}
+
+LayerInfo LayersModel::getRowData(int row) const
+{
+  if (row < 0 || row >= m_vecData.size())
+    return LayerInfo();
+  return m_vecData.at(row);
+}
+
+bool LayersModel::insertRow(const LayerInfo &item)
+{
+  beginInsertRows(QModelIndex(), m_vecData.size(), m_vecData.size());
+  m_vecData.append(item);
+  endInsertRows();
+  return true;
+}
+
+QModelIndex LayersModel::moveRow(const QModelIndex &sourceIndex, int destinationRow)
+{
+  if (destinationRow >= m_vecData.size())
+    return sourceIndex;
+
+  std::swap(m_vecData[destinationRow], m_vecData[sourceIndex.row()]);
+
+  QModelIndex idx = index(destinationRow, 0);
+  emit dataChanged(index(sourceIndex.row(), 0), index(sourceIndex.row(), columnCount(QModelIndex()) - 1));
+  emit dataChanged(idx, index(destinationRow, columnCount(QModelIndex()) - 1));
+
+  return idx;
+}
+
+bool LayersModel::canBeMovedUp(const QModelIndex &idx) const
+{
+  const int row = idx.row();
+  if (row <= 0)
+    return false;
+  const auto &prev = m_vecData.at(row - 1);
+  const auto &cur = m_vecData.at(row);
+  if (prev.layerType != cur.layerType)
+    return false;
+
+  return true;
+}
+
+bool LayersModel::canBeMovedDown(const QModelIndex &idx) const
+{
+  const int row = idx.row();
+  if (row < 0 || row > m_vecData.size() - 1)
+    return false;
+  if (row == m_vecData.size() - 1)
+    return false;
+  const auto &next = m_vecData.at(row + 1);
+  const auto &cur = m_vecData.at(row);
+  if (next.layerType != cur.layerType)
+    return false;
+
+  return true;
+}
+
+QStringList LayersModel::orderLayerNames() const
+{
+  QStringList sl;
+  sl.reserve(m_vecData.size());
+  for (const LayerInfo &li : m_vecData)
+    sl.insert(0, li.layerName);
+
+  return sl;
+}
+
+bool LayersModel::isDisplayNameInFilter(const QString &displayName)
+{
+  for(const QString &name : qAsConst(m_layerDisplayNameFilterList))
+  {
+    if(displayName.compare(name) == 0)
+    {
+      return true;
+    }
+  }
+  return false;
+}
+
+
+} // namespace SituationMap