qt5-legatus-legacy/Lts/Plugins/SituationMapPlugin/Gui/SituationMap/layers_model.cpp

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