src/terralib/qt/plugins/edit/Plugin.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/edit/Plugin.cpp

  \brief Plugin implementation for the TerraLib Edit Qt Plugin.
*/

// TerraLib
#include "../../../common/Config.h"
#include "../../../core/translator/Translator.h"
#include "../../../core/logger/Logger.h"
#include "../../../edit/SnapManager.h"
#include "../../../edit/qt/Renderer.h"
#include "../../../maptools/AbstractLayer.h"
#include "../../af/ApplicationController.h"
#include "../../af/events/ApplicationEvents.h"
#include "../../af/events/LayerEvents.h"
#include "../../af/events/MapEvents.h"
#include "../../widgets/canvas/MapDisplay.h"
#include "../../widgets/canvas/Canvas.h"
#include "../../widgets/layer/explorer/LayerItem.h"
#include "../../widgets/layer/explorer/LayerItemView.h"
#include "Plugin.h"
#include "ToolBar.h"
#include "Stasher.h"
#include "EditedDelegate.h"

// QT
#include <QAction>
#include <QObject>
#include <QMenu>
#include <QMenuBar>

std::list<te::map::AbstractLayer*> GetVisibleLayers(const std::list<te::map::AbstractLayerPtr>& ls)
{
  std::list<te::map::AbstractLayer*> res;

  for(std::list<te::map::AbstractLayerPtr>::const_iterator it = ls.begin(); it != ls.end(); ++it)
    if((*it)->getVisibility() == te::map::VISIBLE)
      res.push_back((*it).get());

  return res;
}

void UpdateTreeView(QTreeView* view)
{
  QModelIndex idx = *view->selectionModel()->selectedIndexes().begin();

  if(view != nullptr && idx.isValid())
  {
    QVector<int> roles;
    roles << Qt::DecorationRole;

#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
       view->dataChanged(idx, idx, roles);
#else
       view->dataChanged(idx, idx);
#endif
  }
}

te::map::AbstractLayer* GetSelectedLayer(QTreeView* view)
{
  QModelIndexList idxs = view->selectionModel()->selectedIndexes();

  if(idxs.isEmpty() || idxs.size() > 1)
    return nullptr;

  te::qt::widgets::TreeItem* item = static_cast<te::qt::widgets::TreeItem*>((*idxs.begin()).internalPointer());

  if(item->getType() != "LAYER")
    return nullptr;

  return ((te::qt::widgets::LayerItem*)item)->getLayer().get();
}

te::qt::plugins::edit::Plugin::Plugin(const te::core::PluginInfo& pluginInfo)
    : te::core::CppPlugin(pluginInfo), m_toolbar(nullptr)
{
}

te::qt::plugins::edit::Plugin::~Plugin() 
{
  delete m_toolbar;
}

void te::qt::plugins::edit::Plugin::startup()
{
  if(m_initialized)
    return;

  // Create the main toolbar
  m_toolbar = new ToolBar(this);

  // Register the application framework listener
  te::qt::af::AppCtrlSingleton::getInstance().addListener(this);

  onUpdateDelegate(true);

  connect(m_toolbar, SIGNAL(triggered(te::qt::af::evt::Event*)), SIGNAL(triggered(te::qt::af::evt::Event*)));
  connect(m_toolbar, SIGNAL(stashed(te::map::AbstractLayer*)), SLOT(onStashedLayer(te::map::AbstractLayer*)));
  connect(m_toolbar, SIGNAL(geometriesEdited()), SLOT(onGeometriesChanged()));
  connect(m_toolbar, SIGNAL(updateDelegate(bool)), SLOT(onUpdateDelegate(bool)));

  // Get plugins menu
  QMenu* pluginsMenu = te::qt::af::AppCtrlSingleton::getInstance().getMenu("Plugins");

  // Insert menu before plugins last action
  m_action = new QAction(this);
  m_action->setText(tr("&Edition Tools"));
  m_action->setIcon(QIcon::fromTheme("layer-edit"));

  pluginsMenu->addAction(m_action);

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

  TE_LOG_TRACE(TE_TR("TerraLib Edit Qt Plugin startup!"));

  m_initialized = true;

  std::set<std::string> sts = GetStashedLayers();

  for(std::set<std::string>::iterator it = sts.begin(); it != sts.end(); ++it)
    m_delegate->addStashed(*it);
}

void te::qt::plugins::edit::Plugin::shutdown()
{
  if(!m_initialized)
    return;

  onUpdateDelegate(false);

  TE_LOG_TRACE(TE_TR("TerraLib Edit Qt Plugin shutdown!"));

  m_initialized = false;

  te::qt::af::AppCtrlSingleton::getInstance().removeListener(this);
}

void te::qt::plugins::edit::Plugin::onActionActivated(bool)
{
  te::qt::af::evt::NewActionsAvailable e;
  e.m_toolbar = m_toolbar->get();
  e.m_category = "Edition";

  emit triggered(&e);
}

void te::qt::plugins::edit::Plugin::onApplicationTriggered(te::qt::af::evt::Event* e)
{
  if (!m_toolbar->isEnabled())
    return;

  switch(e->m_id)
  {
    case te::qt::af::evt::DRAWING_FINISHED:
    {
      drawStashed();
    }
      break;

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

      te::map::AbstractLayer* l = GetSelectedLayer(getLayerExplorer());

      if(l == nullptr)
      {
        m_toolbar->updateLayer(nullptr, false);
        return;
      }

      te::qt::af::evt::GetMapDisplay de;
      emit triggered(&de);

      m_toolbar->updateLayer(evt->m_layer.get(), m_delegate->isStached(evt->m_layer->getTitle()));
    }
      break;

    default:
      break;
  }
}

void te::qt::plugins::edit::Plugin::onStashedLayer(te::map::AbstractLayer* layer)
{
  if(m_delegate->isStached(layer->getTitle()))
  {
    m_delegate->removeStashed(layer->getTitle());
    RemoveStash(layer);

    te::qt::af::evt::GetMapDisplay e;
    emit triggered(&e);

    e.m_display->getDisplay()->refresh();
  }
  else
    m_delegate->addStashed(layer->getTitle());

  UpdateTreeView(getLayerExplorer());
}

void te::qt::plugins::edit::Plugin::onGeometriesChanged()
{
  if (m_toolbar->getSelectedLayer() == nullptr)
    return;

  m_delegate->addEdited(m_toolbar->getSelectedLayer()->getTitle());

  UpdateTreeView(getLayerExplorer());

  drawStashed();
}

void te::qt::plugins::edit::Plugin::drawStashed()
{
  if (!m_toolbar->isEnabled())
    return;
  
  te::qt::af::evt::GetMapDisplay e;
  emit triggered(&e);

  const te::gm::Envelope& env = e.m_display->getDisplay()->getExtent();
  te::edit::SnapManager::getInstance().setWorld(env.m_llx, env.m_lly, env.m_urx, env.m_ury, e.m_display->getDisplay()->getWidth(), e.m_display->getDisplay()->getHeight());

  te::map::AbstractLayer* l = GetSelectedLayer(getLayerExplorer());

  if(l != nullptr && l->getVisibility() == te::map::VISIBLE)
  {
    // Initialize the renderer
    QPixmap* draft = e.m_display->getDisplay()->getDraftPixmap();
    draft->fill(Qt::transparent);

    te::edit::Renderer& renderer = te::edit::Renderer::getInstance();
    renderer.begin(draft, env, e.m_display->getDisplay()->getSRID());

    // Draw the layer edited geometries
    renderer.drawRepository(l->getId(), env, e.m_display->getDisplay()->getSRID());

    renderer.end();
  }

  e.m_display->getDisplay()->repaint();

}

void te::qt::plugins::edit::Plugin::onUpdateDelegate(const bool& add)
{
  te::qt::widgets::LayerItemView* view = getLayerExplorer();

  if(view == nullptr)
    return;

  if(add)
  {
    m_delegate = new EditDelegate((QStyledItemDelegate*)view->itemDelegate(), this);
    view->setItemDelegate(m_delegate);
  }
  else
  {
    view->removeDelegate(m_delegate);
    delete m_delegate;
    m_delegate = nullptr;

    view->repaint();
  }
}

te::qt::widgets::LayerItemView*te::qt::plugins::edit::Plugin::getLayerExplorer()
{
  te::qt::af::evt::GetLayerExplorer e;

  emit triggered(&e);

  return e.m_layerExplorer;
}


TERRALIB_PLUGIN_CALL_BACK_IMPL(te::qt::plugins::edit::Plugin)