LayerItemView.cpp

Go to the documentation of this file.

#include "LayerItemView.h"

#include "LayerItemModel.h"
#include "LayerViewDelegate.h"
#include "LayerViewMenuManager.h"
#include "LayerItem.h"
#include "RuleItem.h"
#include "StyleItem.h"

// Qt
#include <QMouseEvent>

bool Expand(const QModelIndex& idx, te::qt::widgets::LayerItemView* /*view*/)
{
  te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(idx.internalPointer());

  return (item->getType() == "FOLDER");
}

std::list<te::map::AbstractLayerPtr> GetSelectedLayersOnly(te::qt::widgets::LayerItemView* view)
{
  std::list<te::map::AbstractLayerPtr> res;
  std::list<te::qt::widgets::TreeItem*> items = view->getSelectedItems();

  for(std::list<te::qt::widgets::TreeItem*>::iterator it = items.begin(); it != items.end(); ++it)
  if((*it)->getType() == "LAYER")
    res.push_back(((te::qt::widgets::LayerItem*)(*it))->getLayer());

  return res;
}

te::qt::widgets::LayerItemView::LayerItemView(QWidget* parent):
  QTreeView(parent),
  m_outterFilter(nullptr)
{
  setAcceptDrops(true);
  setDragEnabled(true);

  setDefaultDropAction(Qt::MoveAction);

  setRootIsDecorated(true);
  setSelectionMode(QAbstractItemView::ExtendedSelection);

  viewport()->setAutoFillBackground(true);

  m_model = new LayerItemModel(this);

  m_mnuMger = new LayerViewMenuManager(this);

  installEventFilter(m_mnuMger);

  setModel(m_model);

  connect(m_model, SIGNAL(visibilityChanged()), SIGNAL(visibilityChanged()));
  connect(m_model, SIGNAL(styleVisibilityChanged(te::map::AbstractLayerPtr)), SIGNAL(styleVisibilityChanged(te::map::AbstractLayerPtr)));
}

te::qt::widgets::LayerItemView::~LayerItemView() = default;

void te::qt::widgets::LayerItemView::addLayers(const std::list<te::map::AbstractLayerPtr>& layers, const QModelIndex& idx, const std::string& idxPath)
{
  m_model->addLayers(layers, idx, idxPath);

  if(idx.isValid() && Expand(idx, this))
    expand(idx);

  selectionModel()->clearSelection();
}

void te::qt::widgets::LayerItemView::setLayers(const std::list<te::map::AbstractLayerPtr>& layers)
{
  m_model->setLayers(layers);
}

std::list<te::map::AbstractLayerPtr> te::qt::widgets::LayerItemView::getAllLayers() const
{
  return m_model->getAllLayers();
}

std::list<te::map::AbstractLayerPtr> te::qt::widgets::LayerItemView::getVisibleLayers() const
{
  return m_model->getVisibleLayers();
}

std::list<te::qt::widgets::TreeItem*> te::qt::widgets::LayerItemView::getSelectedItems() const
{
  std::list<te::qt::widgets::TreeItem*> res;

  QModelIndexList lst = QTreeView::selectedIndexes();

  qSort(lst);

  for(QModelIndexList::ConstIterator it = lst.begin(); it != lst.end(); ++it)
    res.push_back(static_cast<te::qt::widgets::TreeItem*>((*it).internalPointer()));

  return res;
}

void te::qt::widgets::LayerItemView::addFolder(const std::string& name, const QModelIndex& idx)
{
  m_model->addFolder(name, idx);

  if(idx.isValid() && Expand(idx, this))
    expand(idx);

  selectionModel()->clearSelection();
}

void te::qt::widgets::LayerItemView::updateChart(const QModelIndex& idx)
{
  std::vector<TreeItem*> items;
  TreeItem* item = static_cast<TreeItem*>(idx.internalPointer());

  item->getChildren(items, "CHART");

  if(!items.empty())
  {
    TreeItem* chart = *items.begin();
    int pos = chart->getPosition();

    QModelIndex cIdx = idx.child(pos, 0);

    QModelIndexList ls;

    ls << cIdx;

    removeItems(ls);
  }

  ((LayerItem*)item)->updateChart();

  m_model->insertRows(1, 1, idx);

  QTreeView::expand(idx);
  QTreeView::expand(idx.child(1, 0));
}

void te::qt::widgets::LayerItemView::updateLegend(te::map::AbstractLayer* l)
{
  QModelIndex lIdx = findLayerIndex(model(), QModelIndex(), l);

  if(lIdx.isValid())
  {
    LayerItem* li = static_cast<LayerItem*>(lIdx.internalPointer());

    std::vector<TreeItem*> items;

    li->getChildren(items, "STYLE");

    QModelIndexList ls;

    if (!items.empty())
    {
      TreeItem* g = *items.begin();
      int pos = g->getPosition();

      QModelIndex cIdx = lIdx.child(pos, 0);
      ls << cIdx;
    }

    if (!ls.isEmpty())
      removeItems(ls);

    int pos = li->updateLegend();

    m_model->insertRows(pos, 1, lIdx);

    QTreeView::expand(lIdx);
    QTreeView::expand(lIdx.child(pos, 0));
  }
}

void te::qt::widgets::LayerItemView::addNoLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::NO_LAYERS, act);
}

void te::qt::widgets::LayerItemView::addAllLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::ALL_LAYERS, act);
}

void te::qt::widgets::LayerItemView::addVectorLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::VECTOR_LAYER, act);
}

void te::qt::widgets::LayerItemView::addRasterLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::RASTER_LAYER, act);
}

void te::qt::widgets::LayerItemView::addTabularLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::TABULAR_LAYER, act);
}

void te::qt::widgets::LayerItemView::addFolderLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::FOLDER_LAYER, act);
}

void te::qt::widgets::LayerItemView::addMultipleSelectionAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::MULTI_LAYERS, act);
}

void te::qt::widgets::LayerItemView::addInvalidLayerAction(QAction* act)
{
  m_mnuMger->addAction(LayerViewMenuManager::INVALID_LAYERS, act);
}

void te::qt::widgets::LayerItemView::removeItems(const QModelIndexList& idxs)
{
  m_model->removeItems(idxs);
  selectionModel()->clearSelection();
}

void te::qt::widgets::LayerItemView::removeSelectedItems()
{
  removeItems(selectionModel()->selectedIndexes());
}

void te::qt::widgets::LayerItemView::removeDelegate(QStyledItemDelegate* d)
{
  te::common::Decorator<QStyledItemDelegate>* delegate =
      dynamic_cast< te::common::Decorator<QStyledItemDelegate>* >(itemDelegate());

  if(delegate != nullptr)
  {
    QStyledItemDelegate* newDelegate = delegate->removeDecorator(d);

    if(newDelegate != nullptr)
      setItemDelegate(newDelegate);
  }
}

void te::qt::widgets::LayerItemView::setMenuEventHandler(QObject* obj)
{
  if(m_outterFilter != nullptr)
    removeEventFilter(m_outterFilter);

  if(obj != m_mnuMger)
  {
    removeEventFilter(m_mnuMger);
    m_outterFilter = obj;
  }
  else
    m_outterFilter = nullptr;

  installEventFilter(obj);
}

QObject* te::qt::widgets::LayerItemView::getMenuEventHandler() const
{
  return (m_outterFilter != nullptr) ? m_outterFilter : m_mnuMger;
}

void te::qt::widgets::LayerItemView::removeMenuEventHandler(QObject* handler)
{
  if(m_outterFilter == nullptr)
    return;

  te::common::Decorator<QObject>* h = dynamic_cast< te::common::Decorator<QObject>* >(m_outterFilter);

  if(h != nullptr)
  {
    QObject* newH = h->removeDecorator(handler);

    if(newH != nullptr)
      setMenuEventHandler(newH);
  }
}

void te::qt::widgets::LayerItemView::selectionChanged(const QItemSelection & selected, const QItemSelection & deselected)
{
  QTreeView::selectionChanged(selected, deselected);

  emit selectedLayersChanged(GetSelectedLayersOnly(this));
}

void te::qt::widgets::LayerItemView::dropEvent(QDropEvent * event)
{
  QTreeView::dropEvent(event);

  emit layerOrderChanged();
}

void te::qt::widgets::LayerItemView::mouseDoubleClickEvent(QMouseEvent* event)
{
  QPoint pos = event->globalPos();
  QModelIndex idx = indexAt(viewport()->mapFromGlobal(pos));

  if(idx.isValid())
  {
    TreeItem* item = static_cast<TreeItem*>(idx.internalPointer());

    if(item->getType() == "LAYER")
      emit doubleClicked(((LayerItem*)item)->getLayer());

    if (item->getType() == "STYLE" && item->getParent()->getType() == "LAYER")
    {
      LayerItem* layerItem = (LayerItem*)item->getParent();
      emit styleDoubleClicked(layerItem->getLayer());
    }

    if (item->getType() == "RULE" && item->getParent()->getType() == "STYLE")
    {
      StyleItem* styleItem = (StyleItem*)item->getParent();
      LayerItem* layerItem = (LayerItem*)styleItem->getParent();
      emit ruleDoubleClicked(layerItem->getLayer(), ((RuleItem*)item)->getRule());
    }
  }
}

QModelIndex te::qt::widgets::LayerItemView::findLayerIndex(QAbstractItemModel* model, const QModelIndex& parent, te::map::AbstractLayer* l)
{
  int cs = model->rowCount(parent);

  for (int i = 0; i < cs; i++)
  {
    QModelIndex cIdx = model->index(i, 0, parent);
    te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(cIdx.internalPointer());

    if (item->getType() == "LAYER")
    {
      if (((te::qt::widgets::LayerItem*)item)->getLayer().get() == l)
        return cIdx;
    }
    else if (item->getType() == "FOLDER")
    {
      QModelIndex fIdx = findLayerIndex(model, cIdx, l);

      if (fIdx.isValid())
        return fIdx;
    }
  }

  return QModelIndex();
}