LayerExplorer.cpp

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

    This file is part of TerraView - A GIS Application.

    TerraView is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.

    TerraView is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with TerraLib Code Editor. See COPYING. If not, write to
    TerraLib Team at <terralib-team@dpi.inpe.br>.
 */

// TerraLib
#include "../../../se/ColorMap.h"
#include "../../../se/RasterSymbolizer.h"
#include "../../../se/Rule.h"
#include "../../../se/Utils.h"
#include "../../widgets/layer/explorer/LayerItem.h"
#include "../../widgets/layer/explorer/LayerItemView.h"
#include "../events/Event.h"
#include "../events/ApplicationEvents.h"
#include "../events/LayerEvents.h"
#include "../ApplicationController.h"
#include "LayerExplorer.h"


std::list<te::map::AbstractLayerPtr> GetSelectedLayers(QTreeView* view)
{
  std::list<te::map::AbstractLayerPtr> res;

  QModelIndexList lst = view->selectionModel()->selectedIndexes();

  for(QModelIndexList::iterator it = lst.begin(); it != lst.end(); ++it)
  {
    te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>((*it).internalPointer());

    if(item->getType() == "LAYER")
      res.push_back(((te::qt::widgets::LayerItem*)item)->getLayer());
  }

  return res;
}

void GetAvailableLayers(const QModelIndex& parent, te::qt::widgets::LayerItemView* view, std::list<te::map::AbstractLayerPtr>& layers)
{
  int s = view->model()->rowCount(parent);

  for(int i = 0; i < s; i++)
  {
    QModelIndex childIdx = view->model()->index(i, 0, parent);

    if(childIdx.isValid())
    {
      te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(childIdx.internalPointer());

      if(item->getType() == "LAYER")
        layers.push_back(((te::qt::widgets::LayerItem*)item)->getLayer());
      else if(item->getType() == "FOLDER")
        GetAvailableLayers(childIdx, view, layers);
    }
  }
}

te::qt::af::LayerExplorer::LayerExplorer(te::qt::widgets::LayerItemView* explorer, QObject* parent)
  : QObject(parent),
    m_explorer(explorer)
{
  assert(m_explorer);

  connect(m_explorer, SIGNAL(selectedLayersChanged(std::list<te::map::AbstractLayerPtr>)), SLOT(onSelectedLayersChanged(std::list<te::map::AbstractLayerPtr>)));
  connect(m_explorer, SIGNAL(visibilityChanged()), SLOT(onLayerVisibilityChanged()));
  connect(m_explorer, SIGNAL(styleVisibilityChanged(te::map::AbstractLayerPtr)), SLOT(onStyleVisibilityChanged(te::map::AbstractLayerPtr)));
  connect(m_explorer, SIGNAL(layerOrderChanged()), SLOT(onLayerOrderChanged()));
  connect(m_explorer, SIGNAL(doubleClicked(te::map::AbstractLayerPtr)), SLOT(onTreeItemDoubleClicked(te::map::AbstractLayerPtr)));
  connect(m_explorer, SIGNAL(styleDoubleClicked(te::map::AbstractLayerPtr)), SLOT(onStyleItemDoubleClicked(te::map::AbstractLayerPtr)));
  connect(m_explorer, SIGNAL(ruleDoubleClicked(te::map::AbstractLayerPtr, te::se::Rule*)), SLOT(onRuleItemDoubleClicked(te::map::AbstractLayerPtr, te::se::Rule*)));
}

te::qt::af::LayerExplorer::~LayerExplorer() = default;

te::qt::widgets::LayerItemView* te::qt::af::LayerExplorer::getExplorer() const
{
  return m_explorer;
}

void te::qt::af::LayerExplorer::onApplicationTriggered(te::qt::af::evt::Event* evt)
{
  switch(evt->m_id)
  {
    case te::qt::af::evt::PROJECT_ADDED:
    {
    }
    break;

    case te::qt::af::evt::LAYER_ADDED:
    {
      te::qt::af::evt::LayerAdded* e = static_cast<te::qt::af::evt::LayerAdded*>(evt);
      std::list<te::map::AbstractLayerPtr> layers;
      QModelIndexList lst = m_explorer->selectionModel()->selectedIndexes();

      layers.push_back(e->m_layer);

      QModelIndex par;
      if(!lst.isEmpty())
        par = *lst.begin();

      if(par.isValid())
      {
        te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(par.internalPointer());

        if(item->getType() == "FOLDER")
        {
          m_explorer->addLayers(layers, par);
          m_explorer->expand(par);
        }
        else
          m_explorer->addLayers(layers, QModelIndex());
      }
      else
        m_explorer->addLayers(layers, par);
    }
    break;
    case te::qt::af::evt::LAYERS_ADDED:
    {
      te::qt::af::evt::LayersAdded* e = static_cast<te::qt::af::evt::LayersAdded*>(evt);
      std::list<te::map::AbstractLayerPtr> layers = e->m_layers;
      QModelIndexList lst = m_explorer->selectionModel()->selectedIndexes();

      QModelIndex par;
      if (!lst.isEmpty())
        par = *lst.begin();

      if (par.isValid())
      {
        te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>(par.internalPointer());

        if (item->getType() == "FOLDER")
        {
          m_explorer->addLayers(layers, par);
          m_explorer->expand(par);
        }
        else
          m_explorer->addLayers(layers, QModelIndex());
      }
      else
        m_explorer->addLayers(layers, par);
    }
    break;
    case te::qt::af::evt::ITEM_OF_LAYER_REMOVED:
    {
    }
    break;

    case te::qt::af::evt::LAYER_POPUP_ADD_ACTION:
    {
      te::qt::af::evt::LayerPopUpAddAction* e = static_cast<te::qt::af::evt::LayerPopUpAddAction*>(evt);
      
      QAction* action = e->m_action;

      if (e->m_itemType == "RASTER_LAYER_ITEM")
      {
        m_explorer->addRasterLayerAction(action);
      }
    }
    break;

    case te::qt::af::evt::LAYER_POPUP_REMOVE_ACTION:
    {
      te::qt::af::evt::LayerPopUpRemoveAction* e = static_cast<te::qt::af::evt::LayerPopUpRemoveAction*>(evt);

      m_explorer->removeAction(e->m_action);
    }
    break;

    case te::qt::af::evt::GET_LAYER_SELECTED:
    {
      te::qt::af::evt::GetLayerSelected* e = static_cast<te::qt::af::evt::GetLayerSelected*>(evt);

      std::list<te::map::AbstractLayerPtr> list = GetSelectedLayers(m_explorer);

      if(list.empty() == false)
        e->m_layer = list.front();
    }
    break;

    case te::qt::af::evt::GET_AVAILABLE_LAYERS:
    {
      te::qt::af::evt::GetAvailableLayers* e = static_cast<te::qt::af::evt::GetAvailableLayers*>(evt);
      GetAvailableLayers(QModelIndex(), m_explorer, e->m_layers);
    }
    break;

    case te::qt::af::evt::GET_LAYERS_VIEW:
    {
      te::qt::af::evt::GetLayerExplorer* e = static_cast<te::qt::af::evt::GetLayerExplorer*>(evt);
      e->m_layerExplorer = m_explorer;
    }

    default:
    break;
  }
}

void te::qt::af::LayerExplorer::onSelectedLayersChanged(const std::list<te::map::AbstractLayerPtr>& selectedLayers)
{
  if(selectedLayers.empty())
    return;

  std::list<te::map::AbstractLayerPtr>::const_iterator it;
  for(it = selectedLayers.begin(); it != selectedLayers.end(); ++it)
  {
    te::qt::af::evt::LayerSelected ev(*it);
    emit triggered(&ev);
  }
}

void te::qt::af::LayerExplorer::onLayerVisibilityChanged()
{
  te::qt::af::evt::LayerVisibilityChanged layerVisibilityChangedEvent;
  emit triggered(&layerVisibilityChangedEvent);
}

void te::qt::af::LayerExplorer::onStyleVisibilityChanged(te::map::AbstractLayerPtr layer)
{
  te::qt::af::evt::LayerChanged e2(layer.get(), true);
  emit triggered(&e2);
}

void te::qt::af::LayerExplorer::onLayerOrderChanged()
{
  //te::qt::af::evt::ProjectUnsaved projectUnsavedEvent;
  //emit triggered(&projectUnsavedEvent);
}

void te::qt::af::LayerExplorer::onTreeItemDoubleClicked(
    te::map::AbstractLayerPtr /*layer*/)
{

}

void te::qt::af::LayerExplorer::onStyleItemDoubleClicked(te::map::AbstractLayerPtr layer)
{
  te::qt::af::evt::LayerStyleSelected layerStyleSelected(layer, nullptr);
  emit triggered(&layerStyleSelected);
}

void te::qt::af::LayerExplorer::onRuleItemDoubleClicked(te::map::AbstractLayerPtr layer, te::se::Rule* rule)
{
  te::qt::af::evt::LayerStyleSelected layerStyleSelected(layer, rule);
  emit triggered(&layerStyleSelected);
}