refs #196, encapsulated transponder mode selection (combo box)

* promoted QComboBox in GUI
* features automatic reset for ident
* Conversion to CTransponder::TransponderMode from string

src/blackgui/transpondermodeselector.cpp

@@ -0,0 +1,80 @@
+#include "transpondermodeselector.h"
+
+using namespace BlackMisc::Aviation;
+
+namespace BlackGui
+{
+
+    CTransponderModeSelector::CTransponderModeSelector(QWidget *parent) : QComboBox(parent),
+        m_currentMode(CTransponder::StateStandby), m_resetMode(CTransponder::StateStandby)
+    {
+        QComboBox::insertItems(0, CTransponderModeSelector::modes());
+        connect(&this->m_resetTimer, &QTimer::timeout, this, &CTransponderModeSelector::resetTransponderMode);
+        connect(this, &CTransponderModeSelector::currentTextChanged, this, &CTransponderModeSelector::setSelectedTransponderModeAsString);
+        this->m_resetTimer.setInterval(5000);
+    }
+
+    const QString &CTransponderModeSelector::transponderStateStandby()
+    {
+        static const QString s(BlackMisc::Aviation::CTransponder::modeAsString(BlackMisc::Aviation::CTransponder::StateStandby));
+        return s;
+    }
+
+    const QString &CTransponderModeSelector::transponderStateIdent()
+    {
+        static const QString s(BlackMisc::Aviation::CTransponder::modeAsString(BlackMisc::Aviation::CTransponder::StateIdent));
+        return s;
+    }
+
+    const QString &CTransponderModeSelector::transponderModeC()
+    {
+        static const QString s(BlackMisc::Aviation::CTransponder::modeAsString(BlackMisc::Aviation::CTransponder::ModeC));
+        return s;
+    }
+
+    const QStringList &CTransponderModeSelector::modes()
+    {
+        static QStringList modes;
+        if (modes.isEmpty())
+        {
+            modes << CTransponderModeSelector::transponderStateStandby();
+            modes << CTransponderModeSelector::transponderModeC();
+            modes << CTransponderModeSelector::transponderStateIdent();
+        }
+        return modes;
+    }
+
+    BlackMisc::Aviation::CTransponder::TransponderMode CTransponderModeSelector::getSelectedTransponderMode() const
+    {
+        return this->m_currentMode;
+    }
+
+    void CTransponderModeSelector::setSelectedTransponderMode(CTransponder::TransponderMode mode)
+    {
+        if (mode != CTransponder::StateIdent) this->m_resetMode = mode;
+        if (this->m_currentMode == mode) return;
+        if (this->m_currentMode == CTransponder::StateIdent) emit this->identEnded();
+        this->m_currentMode = mode;
+        QString m = CTransponder::modeAsString(mode);
+        QComboBox::setCurrentText(m);
+        if (mode == CTransponder::StateIdent)
+        {
+            this->m_resetTimer.start();
+        }
+        else
+        {
+            this->m_resetTimer.stop();
+        }
+    }
+
+    void CTransponderModeSelector::setSelectedTransponderModeAsString(const QString &mode)
+    {
+        this->setSelectedTransponderMode(CTransponder::modeFromString(mode));
+    }
+
+    void CTransponderModeSelector::resetTransponderMode()
+    {
+        if (!this->isIdentSelected()) return;
+        this->setSelectedTransponderMode(this->m_resetMode);
+    }
+}

src/blackgui/transpondermodeselector.h

@@ -0,0 +1,73 @@
+#ifndef BLACKGUI_QWITRANSPONDERMODESELECTOR_H
+#define BLACKGUI_QWITRANSPONDERMODESELECTOR_H
+
+#include "../blackmisc/aviotransponder.h"
+#include "blackmisc/aviotransponder.h"
+#include <QTimer>
+#include <QComboBox>
+#include <QStringList>
+
+
+namespace BlackGui
+{
+
+    /*!
+     * \brief Selector for the transponder mode
+     */
+    class CTransponderModeSelector : public QComboBox
+    {
+        Q_OBJECT
+
+    private:
+        BlackMisc::Aviation::CTransponder::TransponderMode m_currentMode;
+        BlackMisc::Aviation::CTransponder::TransponderMode m_resetMode;
+        QTimer m_resetTimer;
+
+    public:
+        //! \brief Constructor
+        explicit CTransponderModeSelector(QWidget *parent = nullptr);
+
+        //! \brief Standby string
+        static const QString &transponderStateStandby();
+
+        //! \brief Ident string
+        static const QString &transponderStateIdent();
+
+        //! \brief Mode C string
+        static const QString &transponderModeC();
+
+        //! \brief All relevant modes for GUI
+        static const QStringList &modes();
+
+        //! \brief Selected transponder mode
+        BlackMisc::Aviation::CTransponder::TransponderMode getSelectedTransponderMode() const;
+
+        //! \brief Selected transponder mode
+        void setSelectedTransponderMode(BlackMisc::Aviation::CTransponder::TransponderMode mode);
+
+        //!\ brief Set to ident
+        void setSelectedTransponderModeStateIdent()
+        {
+            this->setSelectedTransponderMode(BlackMisc::Aviation::CTransponder::StateIdent);
+        }
+
+        //! \brief Ident selected
+        bool isIdentSelected() const
+        {
+            return this->getSelectedTransponderMode() == BlackMisc::Aviation::CTransponder::StateIdent;
+        }
+
+    public slots:
+        //! \brief reset to last mode (unequal ident)
+        void resetTransponderMode();
+
+        //! \brief Selected transponder mode
+        void setSelectedTransponderModeAsString(const QString &mode);
+
+    signals:
+        //! \brief Ident ended
+        void identEnded();
+    };
+} // namespace
+
+#endif // guard

src/blackmisc/aviotransponder.cpp

@@ -47,89 +47,18 @@ namespace BlackMisc
         /*
          * Mode as readable string
          */
-        QString CTransponder::getModeAsString() const
+        CTransponder::TransponderMode CTransponder::modeFromString(const QString &modeString)
         {
-            QString m;
-            switch (this->getTransponderMode())
-            {
-            case StateIdent:
-                m = "Ident";
-                break;
-            case StateStandby:
-                m = "Standby";
-                break;
-            case ModeC:
-                m = "Mode C";
-                break;
-            case ModeS:
-                m = "Mode S";
-                break;
-            case ModeMil1:
-                m = "Mil.Mode 1";
-                break;
-            case ModeMil2:
-                m = "Mil.Mode 2";
-                break;
-            case ModeMil3:
-                m = "Mil.Mode 3";
-                break;
-            case ModeMil4:
-                m = "Mil.Mode 4";
-                break;
-            case ModeMil5:
-                m = "Mil.Mode 5";
-                break;
-            default:
-                throw std::range_error("Illegal Transponder Mode");
-            }
-            return m;
-        }
-
-        /*
-         * Mode as readable string
-         */
-        void CTransponder::setModeAsString(const QString &m)
-        {
-            if (m.startsWith("Ident", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(StateIdent);
-            }
-            else if (m.startsWith("Standby", Qt::CaseInsensitive) || m.startsWith("Stdby", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(StateStandby);
-            }
-            else if (m.startsWith("Mode C", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeC);
-            }
-            else if (m.startsWith("Mode S", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeS);
-            }
-            else if (m.contains("Mode 1", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeMil1);
-            }
-            else if (m.contains("Mode 2", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeMil2);
-            }
-            else if (m.contains("Mode 3", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeMil3);
-            }
-            else if (m.contains("Mode 4", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeMil4);
-            }
-            else if (m.contains("Mode 5", Qt::CaseInsensitive))
-            {
-                this->setTransponderMode(ModeMil5);
-            }
-            else
-            {
-                throw std::range_error("Illegal Transponder Mode");
-            }
+            if (modeString.startsWith("Ident", Qt::CaseInsensitive)) return StateIdent;
+            if (modeString.startsWith("Standby", Qt::CaseInsensitive) || modeString.startsWith("Stdby", Qt::CaseInsensitive)) return StateStandby;
+            if (modeString.startsWith("Mode C", Qt::CaseInsensitive)) return ModeC;
+            if (modeString.startsWith("Mode S", Qt::CaseInsensitive)) return ModeS;
+            if (modeString.contains("Mode 1", Qt::CaseInsensitive)) return ModeMil1;
+            if (modeString.contains("Mode 2", Qt::CaseInsensitive)) return ModeMil2;
+            if (modeString.contains("Mode 3", Qt::CaseInsensitive)) return ModeMil3;
+            if (modeString.contains("Mode 4", Qt::CaseInsensitive)) return ModeMil4;
+            if (modeString.contains("Mode 5", Qt::CaseInsensitive)) return ModeMil5;
+            return StateStandby;
         }
 
         /*
@@ -239,6 +168,47 @@ namespace BlackMisc
             qDBusRegisterMetaType<CTransponder>();
         }
 
+        /*
+         * Mode as readable string
+         */
+        const QString &CTransponder::modeAsString(CTransponder::TransponderMode mode)
+        {
+            static QString m;
+            switch (mode)
+            {
+            case StateIdent:
+                m = "Ident";
+                break;
+            case StateStandby:
+                m = "Standby";
+                break;
+            case ModeC:
+                m = "Mode C";
+                break;
+            case ModeS:
+                m = "Mode S";
+                break;
+            case ModeMil1:
+                m = "Mil.Mode 1";
+                break;
+            case ModeMil2:
+                m = "Mil.Mode 2";
+                break;
+            case ModeMil3:
+                m = "Mil.Mode 3";
+                break;
+            case ModeMil4:
+                m = "Mil.Mode 4";
+                break;
+            case ModeMil5:
+                m = "Mil.Mode 5";
+                break;
+            default:
+                qFatal("Illegal Transponder Mode");
+            }
+            return m;
+        }
+
         /*
          * Members
          */

src/blackmisc/aviotransponder.h

@@ -45,7 +45,7 @@ namespace BlackMisc
              * \brief Validate values by assert and exception
              * \param strict
              * \throws std::range_error
-             * \remarks Cannot be virtualsince already used in constructor
+             * \remarks Cannot be virtual since already used in constructor
              * \return
              */
             bool validate(bool strict = true) const;
@@ -64,7 +64,7 @@ namespace BlackMisc
 
         public:
             //! \brief Default constructor
-            CTransponder() : CAvionicsBase("transponder"), m_transponderCode(0), m_transponderMode(ModeS) {}
+            CTransponder() : CAvionicsBase("transponder"), m_transponderCode(0), m_transponderMode(StateStandby) {}
 
             //! \brief Copy constructor
             CTransponder(const CTransponder &other) : CAvionicsBase(other.getName()),
@@ -133,10 +133,16 @@ namespace BlackMisc
             }
 
             //! \brief Transponder mode as string
-            QString getModeAsString() const;
+            QString getModeAsString() const
+            {
+                return CTransponder::modeAsString(this->getTransponderMode());
+            }
 
             //! \brief Transponder mode as string
-            void setModeAsString(const QString &mode);
+            void setModeAsString(const QString &mode)
+            {
+                this->setTransponderMode(CTransponder::modeFromString(mode));
+            }
 
             //! \brief Transponder mode
             TransponderMode getTransponderMode() const
@@ -144,6 +150,9 @@ namespace BlackMisc
                 return this->m_transponderMode;
             }
 
+            //! \brief Transponder mode as string
+            static const QString &modeAsString(TransponderMode mode);
+
             //! \brief Transponder code
             qint32 getTransponderCode() const
             {
@@ -166,6 +175,9 @@ namespace BlackMisc
             //! \brief Set transponder code
             void setTransponderCode(const QString &transponderCode);
 
+            //! \brief Mode from string
+            static TransponderMode modeFromString(const QString &modeString);
+
             //! \brief Set transponder mode
             void setTransponderMode(TransponderMode mode)
             {