RpToolsWidget.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/rp/RpToolsWidget.cpp

  \brief This file has the RpToolsWidget class.
*/

// TerraLib
#include "../../../geometry/Coord2D.h"
#include "../../../geometry/Geometry.h"
#include "../../../geometry/Point.h"
#include "../../../geometry/Utils.h"
#include "../../../maptools/Utils.h"
#include "../../widgets/tools/AbstractTool.h"
#include "../../widgets/tools/ExtentAcquire.h"
#include "../../widgets/tools/PolygonAcquire.h"
#include "../../widgets/tools/PointPicker.h"
#include "../canvas/Canvas.h"
#include "../canvas/MultiThreadMapDisplay.h"
#include "RpToolsWidget.h"
#include "ui_RpToolsWidgetForm.h"

//QT
#include <QActionGroup>

//STL
#include <memory>


te::qt::widgets::RpToolsWidget::RpToolsWidget(QWidget* parent, Qt::WindowFlags f)
  : QWidget(parent, f),
    m_ui(new Ui::RpToolsWidgetForm),
    m_mapDisplay(nullptr),
    m_actionGroup(nullptr),
    m_pickerAction(nullptr),
    m_geomAction(nullptr),
    m_boxAction(nullptr)
{
  m_ui->setupUi(this);
  m_pointCursor = Qt::CrossCursor;

//signals & slots

  connect(m_ui->m_geomActionToolButton, SIGNAL(toggled(bool)), this, SLOT(onGeomToggled(bool)));
  connect(m_ui->m_extentActionToolButton, SIGNAL(toggled(bool)), this, SLOT(onBoxToggled(bool)));
  connect(m_ui->m_pointActionToolButton, SIGNAL(toggled(bool)), this, SLOT(onPointPickerToggled(bool)));

//pixmap

  m_ui->m_geomActionToolButton->setIcon(QIcon::fromTheme("edit-polygon"));
  m_ui->m_extentActionToolButton->setIcon(QIcon::fromTheme("edit-box"));
  m_ui->m_pointActionToolButton->setIcon(QIcon::fromTheme("placemark"));

  hideEditionTools(true);
}

te::qt::widgets::RpToolsWidget::~RpToolsWidget()
{
  onDisableToolbar();

  delete m_pickerAction;
  delete m_geomAction;
  delete m_boxAction;
}

void te::qt::widgets::RpToolsWidget::setMapDisplay(te::qt::widgets::MapDisplay* mapDisplay)
{
  m_mapDisplay = mapDisplay;
}

void te::qt::widgets::RpToolsWidget::setActionGroup(QActionGroup* actionGroup)
{
  m_actionGroup = actionGroup;
}

void te::qt::widgets::RpToolsWidget::hideEditionTools(bool hide)
{
  m_ui->m_pointActionToolButton->setVisible(!hide);
  m_ui->m_geomActionToolButton->setVisible(!hide);
  m_ui->m_extentActionToolButton->setVisible(!hide);
}

void te::qt::widgets::RpToolsWidget::setPickerTool(bool checked)
{
  if(!checked)
  {
    onDisableToolbar();
    return;
  }

  m_ui->m_pointActionToolButton->setChecked(checked);
  m_pickerAction->setChecked(checked);
}

void te::qt::widgets::RpToolsWidget::setGeomTool(bool checked)
{
  if(!checked)
  {
    onDisableToolbar();
    return;
  }

  m_ui->m_geomActionToolButton->setChecked(checked);
  m_geomAction->setChecked(checked);
}

void te::qt::widgets::RpToolsWidget::setEnvelopeTool(bool checked)
{
  if(!checked)
  {
    onDisableToolbar();
    return;
  }

  m_ui->m_extentActionToolButton->setChecked(checked);
  m_boxAction->setChecked(checked);
}

void te::qt::widgets::RpToolsWidget::setSelectionMode(bool mode)
{
  if(mode)
  {
    m_ui->m_pointActionToolButton->setIcon(QIcon::fromTheme("pointer-selection"));
    m_pointCursor = Qt::ArrowCursor;
  }
  else
  {
    m_ui->m_pointActionToolButton->setIcon(QIcon::fromTheme("placemark"));
    m_pointCursor = Qt::CrossCursor;
  }
}

void te::qt::widgets::RpToolsWidget::onEnvelopeAcquired(te::gm::Envelope env)
{
  //emit signal
  emit envelopeAcquired(env);
}

void te::qt::widgets::RpToolsWidget::onGeomAquired(te::gm::Polygon* poly)
{
  //emit signal
  emit geomAquired(poly);
}

void te::qt::widgets::RpToolsWidget::onPointPicked(QPointF& point)
{
  //emit signal
  emit pointPicked(point.x(), point.y());
}

void te::qt::widgets::RpToolsWidget::onPointPickerMoving(QPointF& point)
{
  //emit signal
  emit pointPickerMoving(point.x(), point.y());
}

void te::qt::widgets::RpToolsWidget::onPointPickerToggled(bool checked)
{
  if (!checked)
    return;

  if(!m_actionGroup->actions().contains(m_pickerAction))
     m_actionGroup->addAction(m_ui->m_pointActionToolButton->defaultAction());

  te::qt::widgets::PointPicker* pp = new te::qt::widgets::PointPicker(m_mapDisplay, m_pointCursor);
  m_mapDisplay->setCurrentTool(pp);
  
  connect(pp, SIGNAL(pointPicked(QPointF&)), this, SLOT(onPointPicked(QPointF&)));
  connect(pp, SIGNAL(pointPickerMoving(QPointF&)), this, SLOT(onPointPickerMoving(QPointF&)));
}

void te::qt::widgets::RpToolsWidget::onGeomToggled(bool checked)
{
  if (!checked)
    return;

  if(!m_actionGroup->actions().contains(m_geomAction))
     m_actionGroup->addAction(m_ui->m_geomActionToolButton->defaultAction());

  te::qt::widgets::PolygonAcquire* pa = new te::qt::widgets::PolygonAcquire(m_mapDisplay);
  m_mapDisplay->setCurrentTool(pa);

  connect(pa, SIGNAL(polygonAquired(te::gm::Polygon*)), this, SLOT(onGeomAquired(te::gm::Polygon*)));
}

void te::qt::widgets::RpToolsWidget::onBoxToggled(bool checked)
{
  if (!checked)
    return;

  if(!m_actionGroup->actions().contains(m_boxAction))
    m_actionGroup->addAction(m_ui->m_extentActionToolButton->defaultAction());

  te::qt::widgets::ExtentAcquire* ea = new te::qt::widgets::ExtentAcquire(m_mapDisplay, Qt::ArrowCursor);
  m_mapDisplay->setCurrentTool(ea);

  connect(ea, SIGNAL(extentAcquired(te::gm::Envelope)), this, SLOT(onEnvelopeAcquired(te::gm::Envelope)));
}

void te::qt::widgets::RpToolsWidget::enablePickerAction()
{
  m_pickerAction = new QAction(this);
  m_pickerAction->setIcon(QIcon::fromTheme("placemark"));
  m_pickerAction->setToolTip(tr("Create by Point"));
  m_pickerAction->setCheckable(true);
  m_pickerAction->setEnabled(true);

  m_ui->m_pointActionToolButton->setDefaultAction(m_pickerAction);

  m_ui->m_pointActionToolButton->setVisible(true);

  m_actionGroup->addAction(m_ui->m_pointActionToolButton->defaultAction());
}

void te::qt::widgets::RpToolsWidget::enableGeomAction()
{
  m_geomAction = new QAction(this);
  m_geomAction->setIcon(QIcon::fromTheme("edit-polygon"));
  m_geomAction->setToolTip(tr("Create by Polygon"));
  m_geomAction->setCheckable(true);
  m_geomAction->setEnabled(true);

  m_ui->m_geomActionToolButton->setDefaultAction(m_geomAction);

  m_ui->m_geomActionToolButton->setVisible(true);

  m_actionGroup->addAction(m_ui->m_geomActionToolButton->defaultAction());
}

void te::qt::widgets::RpToolsWidget::enableBoxAction()
{
  m_boxAction = new QAction(this);
  m_boxAction->setIcon(QIcon::fromTheme("edit-box"));
  m_boxAction->setToolTip(tr("Create by Extent"));
  m_boxAction->setCheckable(true);
  m_boxAction->setEnabled(true);

  m_ui->m_extentActionToolButton->setDefaultAction(m_boxAction);

  m_ui->m_extentActionToolButton->setVisible(true);

  m_actionGroup->addAction(m_ui->m_extentActionToolButton->defaultAction());
}

void te::qt::widgets::RpToolsWidget::onDisableToolbar()
{
  if(m_pickerAction != nullptr && m_pickerAction->isChecked())
  {
    m_pickerAction->setChecked(false);
    m_mapDisplay->setCursor(Qt::ArrowCursor);
    m_mapDisplay->setCurrentTool(nullptr, false);
  }
  else if(m_geomAction != nullptr && m_geomAction->isChecked())
  {
    m_geomAction->setChecked(false);
    m_mapDisplay->setCursor(Qt::ArrowCursor);
    m_mapDisplay->setCurrentTool(nullptr, false);
  }
  else if(m_boxAction != nullptr && m_boxAction->isChecked())
  {
    m_boxAction->setChecked(false);
    m_mapDisplay->setCursor(Qt::ArrowCursor);
    m_mapDisplay->setCurrentTool(nullptr, false);
  }
}