vp/AbstractAction.cpp

Go to the documentation of this file.

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

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

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

    TerraLib 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 Lesser General Public License for more details.

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

/*!
  \file terralib/qt/plugins/vp/AbstractAction.cpp

  \brief This file defines the abstract class AbstractAction
*/

// Terralib
#include "../../../common/SystemApplicationSettings.h"
#include "../../../dataaccess/utils/Utils.h"
#include "../../af/events/LayerEvents.h"
#include "../../af/ApplicationController.h"
#include "AbstractAction.h"

//QT
#include <QApplication>
#include <QCheckBox>
#include <QDir>
#include <QFileInfo>
#include <QMessageBox>

// STL
#include <cassert>

//Boost
#include <boost/filesystem.hpp>

te::qt::plugins::vp::AbstractAction::AbstractAction(QMenu* menu)
    :

      m_menu(menu),
      m_action(nullptr)
{
}

te::qt::plugins::vp::AbstractAction::~AbstractAction() = default;

void te::qt::plugins::vp::AbstractAction::createAction(std::string name, std::string pixmap)
{
  assert(m_menu);

  m_action = new QAction(m_menu);

  m_action->setText(name.c_str());

  if(pixmap.empty() == false)
    m_action->setIcon(QIcon::fromTheme(pixmap.c_str()));

  connect(m_action, SIGNAL(triggered(bool)), this, SLOT(onActionActivated(bool)));

  m_menu->addAction(m_action);
}

void te::qt::plugins::vp::AbstractAction::addNewLayer(te::map::AbstractLayerPtr layer)
{
  te::da::DataSourcePtr dataSource = te::da::GetDataSource(layer->getDataSourceId(), true);
  std::string type = dataSource->getType();

  if(type == "OGR")
  {
    std::string fpath = dataSource->getConnectionInfo().uri();
    bool hasSpatialIndex = hasShapeFileSpatialIndex(QString(fpath.c_str()));

    if(hasSpatialIndex == false)
    {
      configSettings();

      QSettings settings(QSettings::IniFormat,
                         QSettings::UserScope,
                         QApplication::instance()->organizationName(),
                         QApplication::instance()->applicationName());

      bool question = settings.value("vp_config/default_question",
                                     te::common::SystemApplicationSettings::getInstance().getValue("Application.vectorProcessingDefaultQuestion").c_str()).toBool();
      bool option = settings.value("vp_config/spatial_index_as_default",
                                   te::common::SystemApplicationSettings::getInstance().getValue("Application.vectorProcessingSpatialIndexAsDefault").c_str()).toBool();

      if(question == true)
      {

        QCheckBox *askAgain = new QCheckBox("Would you like to save this setting and not ask again?");

        QMessageBox question(QMessageBox::Question, tr("Vector Processing"),
                            tr("Would you like to add spatial index on output layer?"));
        question.addButton(QMessageBox::No);
        question.addButton(QMessageBox::Yes);
        question.setCheckBox(askAgain);

        int addSpatialIndex = question.exec();

        std::unique_ptr<QCheckBox> checkBoxState(question.checkBox());

        if(addSpatialIndex == QMessageBox::Yes)
        {
          if(checkBoxState->isChecked() == true)
          {
            settings.setValue("vp_config/default_question", false);
            settings.setValue("vp_config/spatial_index_as_default", true);
          }

          createSpatialIndex(layer);
        }
        else
        {
          if(checkBoxState->isChecked() == true)
          {
            settings.setValue("vp_config/default_question", false);
            settings.setValue("vp_config/spatial_index_as_default", false);
          }
        }
      }

      if(option == true)
      {
        createSpatialIndex(layer);
      }
    }
  }


  te::qt::af::evt::LayerAdded evt(layer.get());

  emit triggered(&evt);
}

std::list<te::map::AbstractLayerPtr> te::qt::plugins::vp::AbstractAction::getLayers()
{
  te::qt::af::evt::GetAvailableLayers e;
  te::qt::af::evt::GetLayerSelected ed;

  emit triggered(&e);
  emit triggered(&ed);

  std::list<te::map::AbstractLayerPtr> allLayers = e.m_layers;

  std::list<te::map::AbstractLayerPtr> layers;

  for (std::list<te::map::AbstractLayerPtr>::iterator it = allLayers.begin(); it != allLayers.end(); ++it)
  {
    if ((*it)->isValid())
      layers.push_back(*it);
  }

  te::map::AbstractLayerPtr selectedlayer = ed.m_layer;

  if (!selectedlayer || !selectedlayer->isValid())
    return layers;

  std::list<te::map::AbstractLayerPtr> result;

  result.push_back(selectedlayer);

  for (std::list<te::map::AbstractLayerPtr>::iterator it = layers.begin(); it != layers.end(); ++it)
  {
    if ((*it)->getId() != selectedlayer->getId())
      result.push_back(*it);
  }

  return result;
}


bool te::qt::plugins::vp::AbstractAction::hasShapeFileSpatialIndex(const QString& path)
{
  QFileInfo fileInfo(path);

  // Gets the ShapeFile name
  QString fileName = fileInfo.fileName();

  // Builds the ShapeFile directory
  QDir dir(fileInfo.absolutePath());

  // Looking for .qix file
  QString qixFile = fileName;
  qixFile.replace(".shp", ".qix");
  if(dir.exists(qixFile))
    return true;

  // Looking for .sbn file
  QString sbnFile = fileName;
  sbnFile.replace(".shp", ".sbn");
  if(dir.exists(sbnFile))
    return true;

  return false;
}

void te::qt::plugins::vp::AbstractAction::createSpatialIndex(te::map::AbstractLayerPtr layer)
{
  te::da::DataSourcePtr dataSource = te::da::GetDataSource(layer->getDataSourceId(), true);

  try
  {
    std::string command = "CREATE SPATIAL INDEX ON " + layer->getDataSetName();

    dataSource->execute(command);

    QApplication::restoreOverrideCursor();
  }
  catch(...)
  {
    QMessageBox::information(te::qt::af::AppCtrlSingleton::getInstance().getMainWindow(), QObject::tr("Spatial Index"), "Error creating spatial index.");
  }
}

void te::qt::plugins::vp::AbstractAction::configSettings()
{
  // Get user settings
  QSettings settings(QSettings::IniFormat,
                     QSettings::UserScope,
                     QApplication::instance()->organizationName(),
                     QApplication::instance()->applicationName());

  bool contains = settings.contains(QString("vp_config/default_question"));
  if (contains == false)
  {
    settings.beginGroup("vp_config");
    settings.endGroup();

    settings.setValue("vp_config/default_question", true);
    settings.setValue("vp_config/spatial_index_as_default", false);
  }
}