File indexing completed on 2024-04-21 03:49:38

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2008 Henry de Valence <hdevalence@gmail.com>
 // SPDX-FileCopyrightText: 2011 Friedrich W. H. Kossebau <kossebau@kde.org>
 
 
 #include "LatLonEdit.h"
 #include "ui_LatLonEdit.h"
 
 #include "MarbleDebug.h"
 
 
 
 namespace Marble
 {
 
 // This widget can have 3 different designs, one per notation (Decimal, DMS, DM)
 // To reduce the footprint this was not implemented using a stack of widgets
 // where each widget offer the needed design for another notation.
 // Instead, as Decimal and DM are both using subsets of the UI elements used
 // for DMS, just the UI elements for DMS are created and modified as needed,
 // if another notation is selected. This involves showing and hiding them and
 // setting the proper suffix and min/max values.
 // The logic per notation is moved into specialized subclasses of a class 
 // AbstractInputHandler.
 // TODO: simply remove the LatLonEdit.ui file and embed code directly here?
 
 enum { PositiveSphereIndex = 0, NegativeSphereIndex = 1 };
 
 
 class LatLonEditPrivate;
 
 class AbstractInputHandler // TODO: better name
 {
 protected:
     explicit AbstractInputHandler(LatLonEditPrivate *ui) : m_ui(ui) {}
 public:
     virtual ~AbstractInputHandler() {}
 
 public: // API to be implemented
     virtual void setupUi() = 0;
     virtual void setupMinMax(LatLonEdit::Dimension dimension) = 0;
     virtual void setValue(qreal value) = 0;
     virtual void handleIntEditChange() = 0;
     virtual void handleUIntEditChange() = 0;
     virtual void handleFloatEditChange() = 0;
     virtual qreal calculateValue() const = 0;
 
 protected:
     LatLonEditPrivate * const m_ui;
 };
 
 class DecimalInputHandler : public AbstractInputHandler
 {
 public:
     explicit DecimalInputHandler(LatLonEditPrivate *ui) : AbstractInputHandler(ui) {}
 public: // AbstractInputHandler API
     void setupUi() override;
     void setupMinMax(LatLonEdit::Dimension dimension) override;
     void setValue(qreal value) override;
     void handleIntEditChange() override;
     void handleUIntEditChange() override;
     void handleFloatEditChange() override;
     qreal calculateValue() const override;
 };
 
 class DMSInputHandler : public AbstractInputHandler
 {
 public:
     explicit DMSInputHandler(LatLonEditPrivate *ui) : AbstractInputHandler(ui) {}
 public: // AbstractInputHandler API
     void setupUi() override;
     void setupMinMax(LatLonEdit::Dimension dimension) override;
     void setValue(qreal value) override;
     void handleIntEditChange() override;
     void handleUIntEditChange() override;
     void handleFloatEditChange() override;
     qreal calculateValue() const override;
 };
 
 class DMInputHandler : public AbstractInputHandler
 {
 public:
     explicit DMInputHandler(LatLonEditPrivate *ui) : AbstractInputHandler(ui) {}
 public: // AbstractInputHandler API
     void setupUi() override;
     void setupMinMax(LatLonEdit::Dimension dimension) override;
     void setValue(qreal value) override;
     void handleIntEditChange() override;
     void handleUIntEditChange() override;
     void handleFloatEditChange() override;
 
     qreal calculateValue() const override;
 };
 
 class LatLonEditPrivate : public Ui::LatLonEditPrivate
 {
     friend class DecimalInputHandler;
     friend class DMSInputHandler;
     friend class DMInputHandler;
 
 public:
     LatLonEdit::Dimension m_dimension;
     qreal m_value;
     GeoDataCoordinates::Notation m_notation;
     AbstractInputHandler *m_inputHandler;
     // flag which indicates that the widgets are updated due to a change
     // in one of the other widgets. Q*SpinBox does not have a signal which is
     // only emitted by a change due to user input, not code setting a new value.
     // This flag should be less expensive then disconnecting from and reconnecting
     // to the valueChanged signal of all widgets.
     bool m_updating : 1;
 
     LatLonEditPrivate();
     ~LatLonEditPrivate();
     void init(QWidget* parent);
 };
 
 
 static void
 switchSign( QComboBox *sign )
 {
     const bool isNegativeSphere = (sign->currentIndex() == NegativeSphereIndex);
     sign->setCurrentIndex( isNegativeSphere ? PositiveSphereIndex : NegativeSphereIndex );
 }
 
 void DecimalInputHandler::setupUi()
 {
     m_ui->m_floatValueEditor->setSuffix(LatLonEdit::tr("\xC2\xB0")); // the degree symbol °
     m_ui->m_floatValueEditor->setDecimals(5);
 
     m_ui->m_intValueEditor->hide();
     m_ui->m_uintValueEditor->hide();
 }
 
 void DecimalInputHandler::setupMinMax(LatLonEdit::Dimension dimension)
 {
     const qreal maxValue = (dimension == LatLonEdit::Longitude) ? 180.0 : 90.0;
 
     m_ui->m_floatValueEditor->setMinimum(-maxValue);
     m_ui->m_floatValueEditor->setMaximum( maxValue);
 }
 
 void DecimalInputHandler::setValue(qreal value)
 {
     value = qAbs(value);
 
     m_ui->m_floatValueEditor->setValue(value);
 }
 
 void DecimalInputHandler::handleIntEditChange()
 {
     // nothing to do, perhaps rather disconnect the signal with this notation
 }
 
 void DecimalInputHandler::handleUIntEditChange()
 {
     // nothing to do, perhaps rather disconnect the signal with this notation
 }
 
 void DecimalInputHandler::handleFloatEditChange()
 {
     // nothing to do, perhaps rather disconnect the signal with this notation
 }
 
 qreal DecimalInputHandler::calculateValue() const
 {
     qreal value = m_ui->m_floatValueEditor->value();
 
     if (m_ui->m_sign->currentIndex() == NegativeSphereIndex) {
         value *= -1;
     }
 
     return value;
 }
 
 void DMSInputHandler::setupUi()
 {
     m_ui->m_uintValueEditor->setSuffix(LatLonEdit::tr("'"));
     m_ui->m_floatValueEditor->setSuffix(LatLonEdit::tr("\""));
     m_ui->m_floatValueEditor->setDecimals(2);
 
     m_ui->m_intValueEditor->show();
     m_ui->m_uintValueEditor->show();
 }
 
 void DMSInputHandler::setupMinMax(LatLonEdit::Dimension dimension)
 {
     const int maxValue = (dimension == LatLonEdit::Longitude) ? 180 : 90;
 
     m_ui->m_intValueEditor->setMinimum(-maxValue);
     m_ui->m_intValueEditor->setMaximum( maxValue);
 }
 
 void DMSInputHandler::setValue(qreal value)
 {
     value = qAbs( value );
 
     int degValue = (int) value;
 
     qreal minFValue = 60 * (value - degValue);
     int minValue = (int) minFValue;
     qreal secFValue = 60 * (minFValue - minValue);
     // Adjustment for fuzziness (like 49.999999999999999999999)
     int secValue = qRound(secFValue);
     if (secValue > 59) {
         secFValue = 0.0;
         ++minValue;
     }
     if (minValue > 59) {
         minValue = 0;
         ++degValue;
     }
 
     m_ui->m_intValueEditor->setValue( degValue );
     m_ui->m_uintValueEditor->setValue( minValue );
     m_ui->m_floatValueEditor->setValue( secFValue );
 }
 
 void DMSInputHandler::handleIntEditChange()
 {
     const int degValue = m_ui->m_intValueEditor->value();
     const int minDegValue = m_ui->m_intValueEditor->minimum();
     const int maxDegValue = m_ui->m_intValueEditor->maximum();
     // at max/min?
     if (degValue <= minDegValue || maxDegValue <= degValue) {
         m_ui->m_uintValueEditor->setValue( 0 );
         m_ui->m_floatValueEditor->setValue( 0.0 );
     }
 }
 
 void DMSInputHandler::handleUIntEditChange()
 {
     const int degValue = m_ui->m_intValueEditor->value();
     const int minValue = m_ui->m_uintValueEditor->value();
 
     if (minValue < 0) {
         if (degValue != 0) {
             m_ui->m_uintValueEditor->setValue( 59 );
             const int degDec = (degValue > 0) ? 1 : -1;
             m_ui->m_intValueEditor->setValue( degValue - degDec );
         } else {
             switchSign( m_ui->m_sign );
             m_ui->m_uintValueEditor->setValue( 1 );
         }
     } else {
         const int minDegValue = m_ui->m_intValueEditor->minimum();
         const int maxDegValue = m_ui->m_intValueEditor->maximum();
         // at max/min already?
         if (degValue <= minDegValue || maxDegValue <= degValue) {
             // ignore
             m_ui->m_uintValueEditor->setValue( 0 );
         // overflow?
         } else if (minValue >= 60) {
             m_ui->m_uintValueEditor->setValue( 0 );
             // will reach max/min?
             if (minDegValue+1 == degValue || degValue == maxDegValue-1) {
                 // reset also sec
                 m_ui->m_floatValueEditor->setValue( 0.0 );
             }
             const int degInc = (degValue > 0) ? 1 : -1;
             m_ui->m_intValueEditor->setValue( degValue + degInc );
         }
     }
 }
 
 void DMSInputHandler::handleFloatEditChange()
 {
     const int degValue = m_ui->m_intValueEditor->value();
     const int minValue = m_ui->m_uintValueEditor->value();
     const qreal secValue = m_ui->m_floatValueEditor->value();
 
     if (secValue < 0.0) {
         const qreal secDiff = -secValue;
         if (degValue == 0 && minValue == 0) {
             switchSign( m_ui->m_sign );
             m_ui->m_floatValueEditor->setValue( secDiff );
         } else {
             m_ui->m_floatValueEditor->setValue( 60.0 - secDiff );
             if (minValue > 0) {
                 m_ui->m_uintValueEditor->setValue( minValue - 1 );
             } else {
                 m_ui->m_uintValueEditor->setValue( 59 );
                 const int degDec = (degValue > 0) ? 1 : -1;
                 m_ui->m_intValueEditor->setValue( degValue - degDec );
             }
         }
     } else {
         const int minDegValue = m_ui->m_intValueEditor->minimum();
         const int maxDegValue = m_ui->m_intValueEditor->maximum();
         // at max/min already?
         if (degValue <= minDegValue || maxDegValue <= degValue) {
             // ignore
             m_ui->m_floatValueEditor->setValue( 0.0 );
         // need to inc minutes?
         } else if (secValue >= 60.0) {
             qreal newSec = secValue - 60.0;
             // will reach max/min?
             if (minValue == 59) {
                 m_ui->m_uintValueEditor->setValue( 0 );
                 // will reach max/min?
                 if (minDegValue+1 == degValue || degValue == maxDegValue-1) {
                     // reset also sec
                     newSec = 0.0;
                 }
                 const int degInc = (degValue > 0) ? 1 : -1;
                 m_ui->m_intValueEditor->setValue( degValue + degInc );
             } else {
                 m_ui->m_uintValueEditor->setValue( minValue + 1 );
             }
             m_ui->m_floatValueEditor->setValue( newSec );
         }
     }
 }
 
 qreal DMSInputHandler::calculateValue() const
 {
     const bool isNegativeDeg = ( m_ui->m_intValueEditor->value() < 0 );
 
     const qreal deg = (qreal)(qAbs(m_ui->m_intValueEditor->value()));
     const qreal min = (qreal)(m_ui->m_uintValueEditor->value()) / 60.0;
     const qreal sec = m_ui->m_floatValueEditor->value() / 3600.0;
 
     qreal value = deg + min + sec;
 
     if (isNegativeDeg) {
         value *= -1;
     }
     if (m_ui->m_sign->currentIndex() == NegativeSphereIndex) {
         value *= -1;
     }
 
     return value;
 }
 
 void DMInputHandler::setupUi()
 {
     m_ui->m_floatValueEditor->setSuffix(LatLonEdit::tr("'"));
     m_ui->m_floatValueEditor->setDecimals(2);
 
     m_ui->m_intValueEditor->show();
     m_ui->m_uintValueEditor->hide();
 }
 
 void DMInputHandler::setupMinMax(LatLonEdit::Dimension dimension)
 {
     const int maxValue = (dimension == LatLonEdit::Longitude) ? 180 : 90;
 
     m_ui->m_intValueEditor->setMinimum(-maxValue);
     m_ui->m_intValueEditor->setMaximum( maxValue);
 }
 
 void DMInputHandler::setValue(qreal value)
 {
     value = qAbs(value);
 
     int degValue = (int)value;
 
     qreal minFValue = 60 * (value - degValue);
     // Adjustment for fuzziness (like 49.999999999999999999999)
     int minValue = qRound( minFValue );
     if (minValue > 59) {
         minFValue = 0.0;
         ++degValue;
     }
 
     m_ui->m_intValueEditor->setValue( degValue );
     m_ui->m_floatValueEditor->setValue( minFValue );
 }
 
 void DMInputHandler::handleIntEditChange()
 {
     const int degValue = m_ui->m_intValueEditor->value();
     const int minDegValue = m_ui->m_intValueEditor->minimum();
     const int maxDegValue = m_ui->m_intValueEditor->maximum();
     // at max/min?
     if (degValue <= minDegValue || maxDegValue <= degValue) {
         m_ui->m_floatValueEditor->setValue( 0.0 );
     }
 }
 
 void DMInputHandler::handleUIntEditChange()
 {
     // nothing to be done here, should be never called
 }
 
 void DMInputHandler::handleFloatEditChange()
 {
     const int degValue = m_ui->m_intValueEditor->value();
     const qreal minValue = m_ui->m_floatValueEditor->value();
 
     if (minValue < 0.0) {
         const qreal minDiff = -minValue;
         if (degValue == 0) {
             switchSign( m_ui->m_sign );
             m_ui->m_floatValueEditor->setValue( minDiff );
         } else {
             m_ui->m_floatValueEditor->setValue( 60.0 - minDiff );
             m_ui->m_intValueEditor->setValue( degValue - 1 );
         }
     } else {
         const int minDegValue = m_ui->m_intValueEditor->minimum();
         const int maxDegValue = m_ui->m_intValueEditor->maximum();
         // at max/min already?
         if (degValue <= minDegValue || maxDegValue <= degValue) {
             // ignore
             m_ui->m_floatValueEditor->setValue( 0.0 );
         // need to inc degrees?
         } else if (minValue >= 60.0) {
             qreal newMin = minValue - 60.0;
             // will reach max/min?
             if (minDegValue+1 == degValue || degValue == maxDegValue-1) {
                 // reset also sec
                 newMin = 0.0;
             } else {
                 m_ui->m_intValueEditor->setValue( degValue + 1 );
             }
             m_ui->m_floatValueEditor->setValue( newMin );
         }
     }
 }
 
 qreal DMInputHandler::calculateValue() const
 {
     const bool isNegativeDeg = ( m_ui->m_intValueEditor->value() < 0 );
 
     const qreal deg = (qreal)(qAbs(m_ui->m_intValueEditor->value()));
     const qreal min = m_ui->m_floatValueEditor->value() / 60.0;
 
     qreal value = deg + min;
 
     if (isNegativeDeg) {
         value *= -1;
     }
     if (m_ui->m_sign->currentIndex() == NegativeSphereIndex) {
         value *= -1;
     }
 
     return value;
 }
 
 
 LatLonEditPrivate::LatLonEditPrivate()
     : m_dimension(LatLonEdit::Latitude)
     , m_value(0.0)
     , m_notation(GeoDataCoordinates::DMS)
     , m_inputHandler(new DMSInputHandler(this))
     , m_updating(false)
 {}
 
 LatLonEditPrivate::~LatLonEditPrivate()
 {
     delete m_inputHandler;
 }
 
 void LatLonEditPrivate::init(QWidget* parent) { setupUi(parent); }
 
 }
 
 
 using namespace Marble;
 
 LatLonEdit::LatLonEdit(QWidget *parent, LatLonEdit::Dimension dimension, GeoDataCoordinates::Notation notation)
     : QWidget( parent ), d(new LatLonEditPrivate())
 {
     d->init(this);
     setDimension(dimension);
     setNotation(notation);
 
     connect(d->m_intValueEditor,   SIGNAL(valueChanged(int)),    this, SLOT(checkIntValueOverflow()));
     connect(d->m_uintValueEditor,  SIGNAL(valueChanged(int)),    this, SLOT(checkUIntValueOverflow()));
     connect(d->m_floatValueEditor, SIGNAL(valueChanged(double)), this, SLOT(checkFloatValueOverflow()));
 
     connect(d->m_sign, SIGNAL(currentIndexChanged(int)),
                  this, SLOT(onSignChanged()));
 }
 
 LatLonEdit::~LatLonEdit()
 {
     delete d;
 }
 
 qreal LatLonEdit::value() const
 {
     return d->m_value;
 }
 
 GeoDataCoordinates::Notation LatLonEdit::notation() const
 {
     return d->m_notation;
 }
 
 void LatLonEdit::onSignChanged()
 {
     if( d->m_updating )
         return;
 
     // Only flip the value if it does not match the sign
     if (d->m_sign->currentIndex() == PositiveSphereIndex) {
         if (d->m_value < 0.0) {
             d->m_value *= -1;
         }
     } else {
         if (d->m_value > 0.0) {
             d->m_value *= -1;
         }
     }
 
     emit valueChanged( d->m_value );
 }
 
 void LatLonEdit::setDimension( Dimension dimension )
 {
     d->m_dimension = dimension;
 
     d->m_updating = true;
 
     d->m_inputHandler->setupMinMax(dimension);
 
     // update sign widget content
     {
         d->m_sign->clear();
 
         switch (dimension) {
         case Longitude:
             d->m_sign->addItem( tr("E", "East, the direction" ) );
             d->m_sign->addItem( tr("W", "West, the direction" ) );
             break;
         case Latitude:
             d->m_sign->addItem( tr("N", "North, the direction" ) );
             d->m_sign->addItem( tr("S", "South, the direction" ) );
             break;
         }
     }
 
     d->m_updating = false;
 
     // reset value, old one is useless
     setValue( 0.0 );
 }
 
 void LatLonEdit::setNotation(GeoDataCoordinates::Notation notation)
 {
     delete d->m_inputHandler;
     d->m_inputHandler = nullptr;
 
     switch (notation) {
     case GeoDataCoordinates::Decimal:
         d->m_inputHandler = new DecimalInputHandler(d);
         break;
     case GeoDataCoordinates::DMS:
         d->m_inputHandler = new DMSInputHandler(d);
         break;
     case GeoDataCoordinates::DM:
         d->m_inputHandler = new DMInputHandler(d);
         break;
     case GeoDataCoordinates::UTM:
         /** @todo see below */
         break;
     case GeoDataCoordinates::Astro:
         /** @todo see below */
         break;
     }
 
     if (!d->m_inputHandler) {
         /** @todo Temporary fallback to DecimalInputHandler
          *        Implement proper handlers for UTM and Astro */
         d->m_inputHandler = new DecimalInputHandler(d);
     }
 
     d->m_notation = notation;
     d->m_inputHandler->setupUi();
     d->m_inputHandler->setupMinMax(d->m_dimension);
     d->m_inputHandler->setValue(d->m_value);
 }
 
 void LatLonEdit::checkFloatValueOverflow()
 {
     if( d->m_updating )
         return;
 
     d->m_updating = true;
 
     d->m_inputHandler->handleFloatEditChange();
 
     d->m_updating = false;
 
     recalculate();
 }
 
 
 void LatLonEdit::checkUIntValueOverflow()
 {
     if( d->m_updating )
         return;
 
     d->m_updating = true;
 
     d->m_inputHandler->handleUIntEditChange();
 
     d->m_updating = false;
 
     recalculate();
 }
 
 void LatLonEdit::checkIntValueOverflow()
 {
     if( d->m_updating )
         return;
 
     d->m_updating = true;
 
     d->m_inputHandler->handleIntEditChange();
 
     d->m_updating = false;
 
     recalculate();
 }
 
 void LatLonEdit::setValue( qreal value )
 {
     // limit to allowed values
     const qreal maxValue = (d->m_dimension == Longitude) ? 180.0 : 90.0;
 
     if (value > maxValue) {
         value = maxValue;
     } else {
         const qreal minValue = -maxValue;
         if (value < minValue) {
             value = minValue;
         }
     }
 
     // no change?
     if( value == d->m_value ) {
         return;
     }
 
     d->m_value = value;
 
     // calculate sub values
     // calculation is done similar to GeoDataCoordinates::lonToString,
     // perhaps should be moved with similar methods into some utility class/namespace
 
     d->m_updating = true;
 
     d->m_inputHandler->setValue(value);
 
     const bool isNegative = (value < 0.0);
     d->m_sign->setCurrentIndex( isNegative ? NegativeSphereIndex : PositiveSphereIndex );
 
     d->m_updating = false;
 }
 
 void LatLonEdit::recalculate()
 {
     d->m_value = d->m_inputHandler->calculateValue();
 
     emit valueChanged( d->m_value );
 }
 
 
 #include "moc_LatLonEdit.cpp"