InputCoordinateDialog.cpp

Go to the documentation of this file.

#include "InputCoordinateDialog.h"

#include "ui_InputCoordinateForm.h"

// TerraLib
#include "../../../geometry/Coord2D.h"
#include "../Exception.h"

#include "../canvas/MapDisplay.h"

// STL
#include <iostream>

#include <QDoubleValidator>
#include <QPushButton>
#include <QRegularExpression>

// ------------------------------
// Utilities functions section
// ------------------------------

/*!
 * \brief Extracts the degree, minute and second portions of the \a match object.
 *
 * \param match Qt structure that has a regular expression.
 *
 * \param[out] d Degrees.
 *
 * \param[out] m Minutes.
 *
 * \param[out] s Seconds.
 */
void ParseDMS(const QRegularExpressionMatch& match, int& d, int& m, int& s)
{
  d = 999;
  m = 999;
  s = 999;

  QStringList texts = match.capturedTexts();
  bool ok;
  bool negative = false;

  for(int i = 1; i < texts.size(); i++)
  {
    int v = texts.at(i).toInt(&ok);

    if(ok)
    {
      switch(i)
      {
        case 2:
          d = v * ((negative) ? -1 : 1);
        break;

        case 3:
          m = v;
        break;

        case 4:
          s = v;
        break;

        default:
        break;
      }
    }
    else
    {
      if(texts.at(i).compare("-") == 0)
        negative = true;
    }
  }
}

/*!
 * \brief Returns the status of the \a dms construction.
 *
 * \param dms The degree-minute-second value.
 *
 * \param[out] d Degrees.
 *
 * \param[out] m Minutes.
 *
 * \param[out] s Seconds.
 *
 * \return Three possible states: accepted, intermediate, invalid.
 */
QValidator::State IsAValidDMSValue(const QString& dms, int& d, int& m, int& s)
{
  QString aux("^(-)?(\\d{1,3})?");

  aux += QString(QChar(0260)) += " *(\\d{1,2})?' *(\\d{1,2})?''$";

  QRegularExpression r(aux);

  QString dmsS = dms;

  QRegularExpressionMatch match = r.match(dmsS.remove(" "));

  if(!match.hasMatch())
    return QValidator::Invalid;

  ParseDMS(match, d, m, s);

  // If some information is missed, the input can be used.
  if((d == 999) || (m == 999) || (s == 999))
    return QValidator::Intermediate;

  //Checking degrees
  if(!((d >= -180) && (d <= 180)))
    return QValidator::Invalid;

  //Checking minutes
  if(!((m >= 0) && (m <= 60)))
    return QValidator::Invalid;

  //Checking second
  if(!((s >= 0) && (s <= 60)))
    return QValidator::Invalid;

  return QValidator::Acceptable;
}

/*!
 * \overload QValidator::State IsAValidDMSValue(const QString& dms)
 */
QValidator::State IsAValidDMSValue(const QString& dms)
{
  int d,
      m,
      s;

  return IsAValidDMSValue(dms, d, m, s);
}

/*!
 * \brief Returns the value as a formatted string.
 *
 * \param d Degrees.
 *
 * \param m Minutes.
 *
 * \param s Seconds.
 *
 * \return A string formatted as a degrees-minutes-seconds value.
 */
QString GetDMSAsString(const int& d, const int& m, const int& s)
{
  QString dS,
      mS,
      sS;

  // Checking degrees.
  if(d == 999)
    dS = "   0";
  else
  {
    dS = QString::number(d);
    int diff = 4 - dS.size();

    for(int i = 0; i < diff; i++)
      dS = " " + dS;
  }

  // Checking minutes
  if(m == 999)
    mS = " 0";
  else
  {
    mS = QString::number(m);
    int diff = 2 - mS.size();

    for(int i = 0; i < diff; i++)
      mS = " " + mS;
  }

  // Checking seconds
  if(s == 999)
    sS = " 0";
  else
  {
    sS = QString::number(s);
    int diff = 2 - sS.size();

    for(int i = 0; i < diff; i++)
      sS = " " + sS;
  }

  return dS + QString(QChar(0260)) + " " + mS + "' " + sS + "''";
}

/*!
 * \brief Returns the mask to be used by lineEdit objects.
 *
 * \param decimalDegree Flag telling what kind of validators we will use.
 *
 * \return The mask for lineEdits acoording to \a decimalDegree.
 */
QString GetLineEditMask(const bool& decimalDegree)
{
  QString res;

  if(decimalDegree)
    res = QString("###9" + QString(QChar(0260)) + " 00\' 00\'\'");

  return res;
}

/*!
 * \brief Transforms a degree-minute-second value into a decimal-degree value.
 *
 * \param d Degrees.
 *
 * \param m Minutes.
 *
 * \param s Seconds.
 *
 * \return The decimal-degree value.
 */
double DMS2DD(const int& d, const int& m, const int& s)
{
  bool negativeValue = false;
  double dd = 0;

  if (d < 0)
  {
    negativeValue = true;
    dd = d * (-1);
  }
  else
    dd = d;

  double coord = dd + (m / 60.0) + (s / 3600.0);

  coord *= (negativeValue) ? -1 : 1;

  return coord;
}

/*!
 * \brief Transforms a decimal-degree value in a degree-minute-second formatted string.
 *
 * \param value Value in decimal-degrees.
 *
 * \return The degree-minute-second representing the given \a value.
 */
QString DD2DMS(const double& value)
{
  int degree;
  int minute;
  double second;
  double ll;

  degree = static_cast<int>(value);
  ll = value - degree;
  minute = static_cast<int>(ll * 60);
  ll = (ll * 60.) - minute;
  second = ll * 60.;

  return GetDMSAsString(degree, minute, static_cast<int>(std::ceil(second)));
}

/*!
 * \brief Returns a centralized box maintaining the aspect ratio of the older one.
 *
 * \param world The bounding rect of the current visible area.
 *
 * \param center Point where to centralize.
 *
 * \return The new envelope.
 */
te::gm::Envelope GetCenteredBox(const te::gm::Envelope& world, const te::gm::Coord2D& center)
{
  double w = world.getWidth(),
      h = world.getHeight(),
      llx = center.getX() - w/2,
      lly = center.getY() - h/2,
      urx = center.getX() + w/2,
      ury = center.getY() + h/2;

  return te::gm::Envelope(llx, lly, urx, ury);
}

/*!
 * \class DMSValidator
 *
 * \brief Class used to evaluate the coordinates given as degree-minute-second values.
 */
class DMSValidator : public QValidator
{
public:

  /*!
   * \brief Constructor.
   *
   * \param parent Used by Qt to manage the pointers.
   */
  DMSValidator(QWidget* parent = nullptr) :
    QValidator(parent)
  {
  }

  /*!
   * \brief Destructor.
   */
  ~DMSValidator() override = default;

  /*!
   * \brief Verifies if the value is a degree-minute-second valid value.
   *
   * \param value The formatted value.
   *
   * \return Three possible values: accepted, intermediate, invalid.
   */
  State validate(QString& value, int&) const override
  {
    return IsAValidDMSValue(value);
  }

  /*!
   * \brief Used to try to fix some errors on \a value.
   *
   * \param value The string to be fixed.
   */
  void fixup(QString& value) const override
  {
    int d,
        m,
        s;

    QValidator::State state = IsAValidDMSValue(value, d, m, s);

    if(state == QValidator::Intermediate)
      value = GetDMSAsString(d, m, s);
  }
};

// ------------------------------
// End utilities functions section
// ------------------------------

te::qt::widgets::InputCoordinateDialog::InputCoordinateDialog(MapDisplay* display) :
  QDialog(display),
  m_ui(new Ui::InputCoordinateForm),
  m_validator(nullptr),
  m_display(display)
{
  m_ui->setupUi(this);

  updateValidator(true);

  m_ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);

  connect(m_ui->m_Latitude_lineEdit, SIGNAL(editingFinished()), SLOT(validatorStateChanged()));
  connect(m_ui->m_Longitude_lineEdit, SIGNAL(editingFinished()), SLOT(validatorStateChanged()));
}

te::qt::widgets::InputCoordinateDialog::~InputCoordinateDialog()
{
  delete m_ui;
}

void te::qt::widgets::InputCoordinateDialog::DMS_triggered()
{
  if(!m_ui->m_DMS_checkButton->isChecked())
    return;

  double lat,
      lon;

  bool ok;

  QString latS,
      longS;

  lat = m_ui->m_Latitude_lineEdit->text().toDouble(&ok);

  if(!ok)
    return;

  lon = m_ui->m_Longitude_lineEdit->text().toDouble(&ok);

  if(!ok)
    return;

  updateValidator(true);

  m_ui->m_Latitude_lineEdit->setText(DD2DMS(lat));
  m_ui->m_Longitude_lineEdit->setText(DD2DMS(lon));
}

void te::qt::widgets::InputCoordinateDialog::DD_triggered()
{
  if(!m_ui->m_DD_checkButton->isChecked())
    return;

  int d,
      m,
      s;

  double lat = 0,
      lon = 0;

  QValidator::State state = IsAValidDMSValue(m_ui->m_Latitude_lineEdit->text(), d, m, s);

  if(state != QValidator::Invalid)
    lat = DMS2DD(d, m, s);

  state = IsAValidDMSValue(m_ui->m_Longitude_lineEdit->text(), d, m, s);

  if(state != QValidator::Invalid)
    lon = DMS2DD(d, m, s);

  updateValidator(false);

  m_ui->m_Latitude_lineEdit->setText(QString::number(lat));
  m_ui->m_Longitude_lineEdit->setText(QString::number(lon));
}

void te::qt::widgets::InputCoordinateDialog::ok_triggered()
{
  std::unique_ptr<te::gm::Coord2D> coord(getCoordinate());

  int srid = 4326,
      displaySrid = m_display->getSRID();

  te::gm::Envelope env = m_display->getExtent();

  if(srid != displaySrid)
    env.transform(displaySrid, srid);

  env = GetCenteredBox(env, *coord.get());

  if(srid != displaySrid)
    env.transform(srid, displaySrid);

  m_display->setExtent(env, true);
}

void te::qt::widgets::InputCoordinateDialog::cancel_triggered()
{
  reject();
}

void te::qt::widgets::InputCoordinateDialog::validatorStateChanged()
{
  if(m_ui->m_Latitude_lineEdit->text().isEmpty() || m_ui->m_Longitude_lineEdit->text().isEmpty())
    m_ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
  else
    m_ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);

  if(m_ui->m_Latitude_lineEdit->hasAcceptableInput() && m_ui->m_Latitude_lineEdit->hasAcceptableInput())
    m_ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
  else
    m_ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
}

void te::qt::widgets::InputCoordinateDialog::updateValidator(const bool& isDMS)
{
  QString mask = GetLineEditMask(isDMS);

  delete m_validator;

  if(isDMS)
    m_validator = new DMSValidator(this);
  else
    m_validator = new QDoubleValidator(this);

  m_ui->m_Latitude_lineEdit->setInputMask(mask);
  m_ui->m_Latitude_lineEdit->setValidator(m_validator);

  m_ui->m_Longitude_lineEdit->setInputMask(mask);
  m_ui->m_Longitude_lineEdit->setValidator(m_validator);
}

te::gm::Coord2D* te::qt::widgets::InputCoordinateDialog::getCoordinate()
{
  te::gm::Coord2D* coord = nullptr;

  if(m_ui->m_DMS_checkButton->isChecked())
  {
    int d,
        m,
        s;
    double x,
        y;

    QValidator::State state = IsAValidDMSValue(m_ui->m_Latitude_lineEdit->text(), d, m, s);

    if(state != QValidator::Invalid)
    {
      x = DMS2DD(d, m, s);

      state = IsAValidDMSValue(m_ui->m_Longitude_lineEdit->text(), d, m, s);

      if(state != QValidator::Invalid)
      {
        y = DMS2DD(d, m, s);

        coord = new te::gm::Coord2D(x, y);
      }

    }
  }
  else
  {
    double x,
        y;
    bool ok;

    x = m_ui->m_Latitude_lineEdit->text().toDouble(&ok);

    if(ok)
    {
      y = m_ui->m_Longitude_lineEdit->text().toDouble(&ok);

      if(ok)
        coord = new te::gm::Coord2D(x, y);
    }
  }

  return coord;
}