gdal/GeoFileDragAndDropHandler.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/widgets/utils/GeoFileDragAndDropHandler.h

\brief A class used to handle geofile drag and drop events.
*/

#include "../../../widgets/layer/explorer/LayerItemView.h"
#include "GeoFileDragAndDropHandler.h"
#include "Utils.h"

// Terralib
#include "../../../../dataaccess/datasource/DataSource.h"
#include "../../../../dataaccess/datasource/DataSourceFactory.h"
#include "../../../../maptools/Utils.h"
#include "../../../widgets/canvas/MultiThreadMapDisplay.h"
#include "../../../af/events/MapEvents.h"

// Qt
#include <QDragEnterEvent>
#include <QEvent>
#include <QMimeData>
#include <QUrl>

bool IsSupported(const std::string& fileName)
{
  std::string connInfo("file://" + fileName);

  std::unique_ptr<te::da::DataSource> ds(te::da::DataSourceFactory::make("GDAL", connInfo));

  try
  {
    ds->open();

    te::da::DataSetTypePtr dsType;

    std::vector<std::string> dsets = ds->getDataSetNames();

    if (dsets.size() == 0)
      return false;

    dsType = ds->getDataSetType(dsets[0]);

    if (dsType.get() == nullptr)
      return false;
  }
  catch (const std::exception&)
  {
    return false;
  }
  catch (...)
  {
    return false;
  }

  return true;
}

te::qt::plugins::gdal::GeoFileDragAndDropHandler::GeoFileDragAndDropHandler(QObject* parent) :
  QObject(parent), 
  m_isValid(false)
{

}

te::qt::plugins::gdal::GeoFileDragAndDropHandler::~GeoFileDragAndDropHandler() =
    default;

bool te::qt::plugins::gdal::GeoFileDragAndDropHandler::eventFilter(QObject* watched, QEvent* e)
{
  if (e->type() == QEvent::DragEnter)
  {
    QDragEnterEvent* dragEvent = dynamic_cast<QDragEnterEvent*>(e);
    dragEvent->setDropAction(Qt::DropAction::LinkAction);

    const QMimeData* mimeData = dragEvent->mimeData();

    QList<QUrl> urlList = mimeData->urls();

    m_isValid = false;

    // extract the local paths of the files
    for (int i = 0; i < urlList.size(); ++i)
    {
      std::string fileName = urlList.at(i).toLocalFile().toUtf8().constData();

      if (IsSupported(fileName))
      {
        m_isValid = true;
        break;
      }
    }

    if (m_isValid)
    {
      dragEvent->accept();
      return true;
    }
    else
    {
      return QObject::eventFilter(watched, e);
    }
  }
  else if (e->type() == QEvent::Drop && m_isValid)
  {
    QDropEvent* dropEvent = dynamic_cast<QDropEvent*>(e);

    const QMimeData* mimeData = dropEvent->mimeData();

    QStringList pathList;
    QList<QUrl> urlList = mimeData->urls();

    // extract the local paths of the files
    for (int i = 0; i < urlList.size(); ++i)
    {
      pathList.append(urlList.at(i).toLocalFile());
    }

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

    te::qt::plugins::gdal::CreateLayers(pathList, layers);

    te::qt::widgets::MultiThreadMapDisplay* mtmd = dynamic_cast<te::qt::widgets::MultiThreadMapDisplay*>(watched);

    if (mtmd)
    {
      std::list<te::map::AbstractLayerPtr> curList = mtmd->getLayerList();
      std::list<te::map::AbstractLayerPtr>::const_iterator it = layers.begin();

      while (it != layers.end())
      {
        (*it)->setVisibility(te::map::VISIBLE);

        curList.push_back(*it);

        ++it;
      }

      if (mtmd->getSRID() == TE_UNKNOWN_SRS)
      {
        configSRS(curList, mtmd);
      }

      te::gm::Envelope displayExtent = te::map::GetExtent(curList, mtmd->getSRID(), true);
      mtmd->setExtent(displayExtent, false);

      mtmd->setLayerList(curList);
      mtmd->refresh(true);
    }

    return true;
  }

  return QObject::eventFilter(watched, e);
}

void te::qt::plugins::gdal::GeoFileDragAndDropHandler::configSRS(const std::list<te::map::AbstractLayerPtr>& layers, te::qt::widgets::MapDisplay* mapDisplay)
{
  if (layers.size() == 1 && (*layers.begin())->getSRID() == TE_UNKNOWN_SRS && mapDisplay->getSRID() != TE_UNKNOWN_SRS)
  {
    const te::map::AbstractLayerPtr& layer = *layers.begin();

    mapDisplay->setSRID(TE_UNKNOWN_SRS, false);

    std::pair<int, std::string> srid(layer->getSRID(), "EPSG");
    te::qt::af::evt::MapSRIDChanged mapSRIDChanged(srid);
    emit triggered(&mapSRIDChanged);
  }
  else if (mapDisplay->getSRID() == TE_UNKNOWN_SRS)
  {
    std::list<te::map::AbstractLayerPtr>::const_iterator it;

    for (it = layers.begin(); it != layers.end(); ++it)
    {
      const te::map::AbstractLayerPtr& layer = *it;

      if (layer->getSRID() == TE_UNKNOWN_SRS)
        continue;

      mapDisplay->setSRID(layer->getSRID(), false);

      std::pair<int, std::string> srid(layer->getSRID(), "EPSG");

      te::qt::af::evt::MapSRIDChanged mapSRIDChanged(srid);
      emit triggered(&mapSRIDChanged);

      break;
    }
  }
}