PointMove.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/tools/PointMove.cpp

  \brief This class implements a concrete tool to geographic coordinate move a point on mouse click operation.
*/

// TerraLib
#include "../../../maptools/MarkRendererManager.h"
#include "../../../se/Mark.h"
#include "../../../se/Stroke.h"
#include "../../../se/Utils.h"
#include "../canvas/Canvas.h"
#include "../canvas/MapDisplay.h"
#include "PointMove.h"

// Qt
#include <QMouseEvent>

#define PATTERN_SIZE 12

te::qt::widgets::PointMove::PointMove(te::qt::widgets::MapDisplay* display,  std::map<unsigned int, QPointF>* points, const QCursor& cursor, QObject* parent) 
  : AbstractTool(display, parent),
  m_moveStarted(false)
{
  setCursor(cursor);
  m_points = points;
}

te::qt::widgets::PointMove::~PointMove()
{
}

bool te::qt::widgets::PointMove::mousePressEvent(QMouseEvent* e)
{
  if(e->button() != Qt::LeftButton)
    return false;

#if QT_VERSION >= 0x050000
  QPointF p = e->localPos();
#else
  QPointF p = e->posF();
#endif

  te::gm::Envelope env = buildEnvelope(p);

  m_moveStarted = false;

  if (m_points->size())
  {
    for (std::map<unsigned int, QPointF>::iterator it = m_points->begin(); it != m_points->end(); ++it)
    {
      te::gm::Envelope env_pt((*it).second.x(), (*it).second.y(), (*it).second.x(), (*it).second.y());
      if (env.contains(env_pt))
      {
        m_ptMoving = (*it).first;
        m_origin = (*it).second;
        m_moveStarted = true;
        break;
      }
    }
  }

  if (m_moveStarted)
    draw();

  return true;
}

bool te::qt::widgets::PointMove::mouseMoveEvent(QMouseEvent* e)
{
#if QT_VERSION >= 0x050000
  QPointF p = e->localPos();
#else
  QPointF p = e->posF();
#endif

  p = m_display->transform(p);
  if (m_moveStarted)
  {
    m_points->at(m_ptMoving).setX(p.x());
    m_points->at(m_ptMoving).setY(p.y());

    draw();
  }
  else
    m_display->repaint();

  if (!p.isNull())
    emit pointMoveMoving(p);

  return true;
}

bool te::qt::widgets::PointMove::mouseReleaseEvent(QMouseEvent* e)
{
  if (m_moveStarted)
  {
#if QT_VERSION >= 0x050000
    QPointF p = e->localPos();
#else
    QPointF p = e->posF();
#endif

    p = m_display->transform(p);

    m_moveStarted = false;

    if (!p.isNull())
    {
      m_points->at(m_ptMoving) = p;
      emit pointMoved(m_origin, p);
    }
  }

  return true;
}


te::gm::Envelope te::qt::widgets::PointMove::buildEnvelope(const QPointF& pos)
{
  QPointF pixelOffset(4.0, 4.0);

  QRectF rect(pos - pixelOffset, pos + pixelOffset);

  // Converts rect boundary to world coordinates
  QPointF ll(rect.left(), rect.bottom());
  QPointF ur(rect.right(), rect.top());
  ll = m_display->transform(ll);
  ur = m_display->transform(ur);

  te::gm::Envelope env(ll.x(), ll.y(), ur.x(), ur.y());

  return env;
}

void te::qt::widgets::PointMove::draw()
{
  const te::gm::Envelope& env = m_display->getExtent();
  if (!env.isValid())
    return;

  te::se::Stroke* strokeSel = te::se::CreateStroke("#000000", "1");
  te::se::Fill* fillSel = te::se::CreateFill("#FF0000", "1.0");
  te::se::Mark* markSelected = te::se::CreateMark("cross", strokeSel, fillSel);
  te::color::RGBAColor** rgbaMarkSelected = te::map::MarkRendererManager::getInstance().render(markSelected, PATTERN_SIZE);
  //define mark unselected

  te::se::Stroke* strokeUnsel = te::se::CreateStroke("#000000", "1");
  te::se::Fill* fillUnsel = te::se::CreateFill("#00FF00", "1.0");
  te::se::Mark* markUnselected = te::se::CreateMark("cross", strokeUnsel, fillUnsel);
  te::color::RGBAColor** rgbaMarkUnselected = te::map::MarkRendererManager::getInstance().render(markUnselected, PATTERN_SIZE);

  // Clear!
  QPixmap* draft = m_display->getDraftPixmap();
  draft->fill(Qt::transparent);

  std::unique_ptr<te::qt::widgets::Canvas> CanvasInstance(new te::qt::widgets::Canvas(draft));
  CanvasInstance->setWindow(env.m_llx, env.m_lly, env.m_urx, env.m_ury);
  CanvasInstance->setTextContourEnabled(true);
  CanvasInstance->setTextContourWidth(2);
  CanvasInstance->setTextContourColor(te::color::RGBAColor(0, 0, 0, TE_OPAQUE));

  for (std::map<unsigned int, QPointF> :: iterator it = m_points->begin(); it != m_points->end(); ++it)
  {
    unsigned int i = (*it).first;
    QPointF pt = (*it).second;
    if (i == m_ptMoving)
    {
      CanvasInstance->setPointPattern(rgbaMarkSelected, PATTERN_SIZE, PATTERN_SIZE);
      CanvasInstance->setTextColor(te::color::RGBAColor(255, 0, 0, TE_OPAQUE));
    }
    else
    {
      CanvasInstance->setPointPattern(rgbaMarkUnselected, PATTERN_SIZE, PATTERN_SIZE);
      CanvasInstance->setTextColor(te::color::RGBAColor(0, 255, 0, TE_OPAQUE));
    }

    te::gm::Point Point(pt.x(), pt.y());
    CanvasInstance->draw(&Point);
    //ref text
    QMatrix matrix = CanvasInstance->getMatrix();
    QPointF pointCanvas = matrix.map(pt);
    pointCanvas.setY(pointCanvas.y() + 15);
    QPointF pointGeo = matrix.inverted().map(pointCanvas);
    Point.setX(pointGeo.x());
    Point.setY(pointGeo.y());
    CanvasInstance->drawText(&Point, QString::number(i).toUtf8().data());
  }

  m_display->repaint();

}