Antenna tools feature: Make settings assignments atomic. Part of #1329

plugins/feature/antennatools/antennatools.cpp

@@ -71,7 +71,7 @@ bool AntennaTools::handleMessage(const Message& cmd)
     {
         MsgConfigureAntennaTools& cfg = (MsgConfigureAntennaTools&) cmd;
         qDebug() << "AntennaTools::handleMessage: MsgConfigureAntennaTools";
-        applySettings(cfg.getSettings(), cfg.getForce());
+        applySettings(cfg.getSettings(), cfg.getSettingsKeys(), cfg.getForce());
 
         return true;
     }
@@ -90,66 +90,31 @@ bool AntennaTools::deserialize(const QByteArray& data)
 {
     if (m_settings.deserialize(data))
     {
-        MsgConfigureAntennaTools *msg = MsgConfigureAntennaTools::create(m_settings, true);
+        MsgConfigureAntennaTools *msg = MsgConfigureAntennaTools::create(m_settings, QList<QString>(), true);
         m_inputMessageQueue.push(msg);
         return true;
     }
     else
     {
         m_settings.resetToDefaults();
-        MsgConfigureAntennaTools *msg = MsgConfigureAntennaTools::create(m_settings, true);
+        MsgConfigureAntennaTools *msg = MsgConfigureAntennaTools::create(m_settings, QList<QString>(), true);
         m_inputMessageQueue.push(msg);
         return false;
     }
 }
 
-void AntennaTools::applySettings(const AntennaToolsSettings& settings, bool force)
+void AntennaTools::applySettings(const AntennaToolsSettings& settings, const QList<QString>& settingsKeys, bool force)
 {
-    qDebug() << "AntennaTools::applySettings:"
+    qDebug() << "AntennaTools::applySettings:" << settings.getDebugString(settingsKeys, force) << " force: " << force;
-            << " m_title: " << settings.m_title
-            << " m_rgbColor: " << settings.m_rgbColor
-            << " m_useReverseAPI: " << settings.m_useReverseAPI
-            << " m_reverseAPIAddress: " << settings.m_reverseAPIAddress
-            << " m_reverseAPIPort: " << settings.m_reverseAPIPort
-            << " m_reverseAPIFeatureSetIndex: " << settings.m_reverseAPIFeatureSetIndex
-            << " m_reverseAPIFeatureIndex: " << settings.m_reverseAPIFeatureIndex
-            << " force: " << force;
 
-    QList<QString> reverseAPIKeys;
+    if (settingsKeys.contains("useReverseAPI"))
-
-    if ((m_settings.m_dipoleFrequencyMHz != settings.m_dipoleFrequencyMHz) || force) {
-        reverseAPIKeys.append("dipoleFrequencyMHz");
-    }
-    if ((m_settings.m_dipoleEndEffectFactor != settings.m_dipoleEndEffectFactor) || force) {
-        reverseAPIKeys.append("dipoleEndEffectFactor");
-    }
-    if ((m_settings.m_dishFrequencyMHz != settings.m_dishFrequencyMHz) || force) {
-        reverseAPIKeys.append("dishFrequencyMHz");
-    }
-    if ((m_settings.m_dishDiameter != settings.m_dishDiameter) || force) {
-        reverseAPIKeys.append("dishDiameter");
-    }
-    if ((m_settings.m_dishDepth != settings.m_dishDepth) || force) {
-        reverseAPIKeys.append("dishDepth");
-    }
-    if ((m_settings.m_dishEfficiency != settings.m_dishEfficiency) || force) {
-        reverseAPIKeys.append("dishEfficiency");
-    }
-    if ((m_settings.m_title != settings.m_title) || force) {
-        reverseAPIKeys.append("title");
-    }
-    if ((m_settings.m_rgbColor != settings.m_rgbColor) || force) {
-        reverseAPIKeys.append("rgbColor");
-    }
-
-    if (settings.m_useReverseAPI)
     {
-        bool fullUpdate = ((m_settings.m_useReverseAPI != settings.m_useReverseAPI) && settings.m_useReverseAPI) ||
+        bool fullUpdate = (settingsKeys.contains("useReverseAPI") && settings.m_useReverseAPI) ||
-                (m_settings.m_reverseAPIAddress != settings.m_reverseAPIAddress) ||
+                settingsKeys.contains("reverseAPIAddress") ||
-                (m_settings.m_reverseAPIPort != settings.m_reverseAPIPort) ||
+                settingsKeys.contains("reverseAPIPort") ||
-                (m_settings.m_reverseAPIFeatureSetIndex != settings.m_reverseAPIFeatureSetIndex) ||
+                settingsKeys.contains("reverseAPIFeatureSetIndex") ||
-                (m_settings.m_reverseAPIFeatureIndex != settings.m_reverseAPIFeatureIndex);
++                settingsKeys.contains("m_reverseAPIFeatureIndex");
-        webapiReverseSendSettings(reverseAPIKeys, settings, fullUpdate || force);
+        webapiReverseSendSettings(settingsKeys, settings, fullUpdate || force);
     }
 
     m_settings = settings;
@@ -176,12 +141,12 @@ int AntennaTools::webapiSettingsPutPatch(
     AntennaToolsSettings settings = m_settings;
     webapiUpdateFeatureSettings(settings, featureSettingsKeys, response);
 
-    MsgConfigureAntennaTools *msg = MsgConfigureAntennaTools::create(settings, force);
+    MsgConfigureAntennaTools *msg = MsgConfigureAntennaTools::create(settings, featureSettingsKeys, force);
     m_inputMessageQueue.push(msg);
 
     if (m_guiMessageQueue) // forward to GUI if any
     {
-        MsgConfigureAntennaTools *msgToGUI = MsgConfigureAntennaTools::create(settings, force);
+        MsgConfigureAntennaTools *msgToGUI = MsgConfigureAntennaTools::create(settings, featureSettingsKeys, force);
         m_guiMessageQueue->push(msgToGUI);
     }
 
@@ -283,7 +248,7 @@ void AntennaTools::webapiUpdateFeatureSettings(
     }
 }
 
-void AntennaTools::webapiReverseSendSettings(QList<QString>& featureSettingsKeys, const AntennaToolsSettings& settings, bool force)
+void AntennaTools::webapiReverseSendSettings(const QList<QString>& featureSettingsKeys, const AntennaToolsSettings& settings, bool force)
 {
     SWGSDRangel::SWGFeatureSettings *swgFeatureSettings = new SWGSDRangel::SWGFeatureSettings();
     // swgFeatureSettings->setOriginatorFeatureIndex(getIndexInDeviceSet());

plugins/feature/antennatools/antennatools.h

@@ -45,19 +45,22 @@ public:
 
     public:
         const AntennaToolsSettings& getSettings() const { return m_settings; }
+        const QList<QString>& getSettingsKeys() const { return m_settingsKeys; }
         bool getForce() const { return m_force; }
 
-        static MsgConfigureAntennaTools* create(const AntennaToolsSettings& settings, bool force) {
+        static MsgConfigureAntennaTools* create(const AntennaToolsSettings& settings, const QList<QString>& settingsKeys, bool force) {
-            return new MsgConfigureAntennaTools(settings, force);
+            return new MsgConfigureAntennaTools(settings, settingsKeys, force);
         }
 
     private:
         AntennaToolsSettings m_settings;
+        QList<QString> m_settingsKeys;
         bool m_force;
 
-        MsgConfigureAntennaTools(const AntennaToolsSettings& settings, bool force) :
+        MsgConfigureAntennaTools(const AntennaToolsSettings& settings, const QList<QString>& settingsKeys, bool force) :
             Message(),
             m_settings(settings),
+            m_settingsKeys(settingsKeys),
             m_force(force)
         { }
     };
@@ -102,8 +105,8 @@ private:
     QNetworkAccessManager *m_networkManager;
     QNetworkRequest m_networkRequest;
 
-    void applySettings(const AntennaToolsSettings& settings, bool force = false);
+    void applySettings(const AntennaToolsSettings& settings, const QList<QString>& settingsKeys, bool force = false);
-    void webapiReverseSendSettings(QList<QString>& featureSettingsKeys, const AntennaToolsSettings& settings, bool force);
+    void webapiReverseSendSettings(const QList<QString>& featureSettingsKeys, const AntennaToolsSettings& settings, bool force);
 
 private slots:
     void networkManagerFinished(QNetworkReply *reply);

plugins/feature/antennatools/antennatoolsgui.cpp

@@ -77,7 +77,13 @@ bool AntennaToolsGUI::handleMessage(const Message& message)
     {
         qDebug("AntennaToolsGUI::handleMessage: AntennaTools::MsgConfigureAntennaTools");
         const AntennaTools::MsgConfigureAntennaTools& cfg = (AntennaTools::MsgConfigureAntennaTools&) message;
+
+        if (cfg.getForce()) {
             m_settings = cfg.getSettings();
+        } else {
+            m_settings.applySettings(cfg.getSettingsKeys(), cfg.getSettings());
+        }
+
         blockApplySettings(true);
         displaySettings();
         blockApplySettings(false);
@@ -229,6 +235,14 @@ void AntennaToolsGUI::onMenuDialogCalled(const QPoint &p)
         setTitle(m_settings.m_title);
         setTitleColor(m_settings.m_rgbColor);
 
+        m_settingsKeys.append("title");
+        m_settingsKeys.append("rgbColor");
+        m_settingsKeys.append("useReverseAPI");
+        m_settingsKeys.append("reverseAPIAddress");
+        m_settingsKeys.append("reverseAPIPort");
+        m_settingsKeys.append("reverseAPIFeatureSetIndex");
+        m_settingsKeys.append("reverseAPIFeatureIndex");
+
         applySettings();
     }
 
@@ -280,9 +294,11 @@ void AntennaToolsGUI::applySettings(bool force)
 {
     if (m_doApplySettings)
     {
-        AntennaTools::MsgConfigureAntennaTools* message = AntennaTools::MsgConfigureAntennaTools::create(m_settings, force);
+        AntennaTools::MsgConfigureAntennaTools* message = AntennaTools::MsgConfigureAntennaTools::create(m_settings, m_settingsKeys, force);
         m_antennatools->getInputMessageQueue()->push(message);
     }
+
+    m_settingsKeys.clear();
 }
 
 void AntennaToolsGUI::calcDipoleLength()
@@ -328,14 +344,18 @@ double AntennaToolsGUI::calcDipoleFrequency(double totalLength)
 void AntennaToolsGUI::on_dipoleFrequencySelect_currentIndexChanged(int index)
 {
     m_settings.m_dipoleFrequencySelect = index;
+    m_settingsKeys.append("dipoleFrequencySelect");
     applySettings();
+
     if (index >= 1)
     {
         double frequency = getDeviceSetFrequencyMHz(index - 1);
+
         if (frequency >= 0.0) {
             ui->dipoleFrequency->setValue(frequency);
         }
     }
+
     ui->dipoleFrequency->setReadOnly(index >= 1);
     ui->dipoleLength->setReadOnly(index >= 1);
     ui->dipoleElementLength->setReadOnly(index >= 1);
@@ -344,6 +364,7 @@ void AntennaToolsGUI::on_dipoleFrequencySelect_currentIndexChanged(int index)
 void AntennaToolsGUI::on_dipoleFrequency_valueChanged(double value)
 {
     m_settings.m_dipoleFrequencyMHz = value;
+    m_settingsKeys.append("dipoleFrequencyMHz");
     applySettings();
     calcDipoleLength();
 }
@@ -351,6 +372,7 @@ void AntennaToolsGUI::on_dipoleFrequency_valueChanged(double value)
 void AntennaToolsGUI::on_dipoleEndEffectFactor_valueChanged(double value)
 {
     m_settings.m_dipoleEndEffectFactor = value;
+    m_settingsKeys.append("dipoleEndEffectFactor");
     applySettings();
     calcDipoleLength();
 }
@@ -358,6 +380,7 @@ void AntennaToolsGUI::on_dipoleEndEffectFactor_valueChanged(double value)
 void AntennaToolsGUI::on_dipoleLengthUnits_currentIndexChanged(int index)
 {
     m_settings.m_dipoleLengthUnits = (AntennaToolsSettings::LengthUnits)index;
+    m_settingsKeys.append("dipoleLengthUnits");
     applySettings();
     calcDipoleLength();
 }
@@ -365,6 +388,7 @@ void AntennaToolsGUI::on_dipoleLengthUnits_currentIndexChanged(int index)
 void AntennaToolsGUI::on_dipoleLength_valueChanged(double value)
 {
     m_settings.m_dipoleFrequencyMHz = calcDipoleFrequency(value);
+    m_settingsKeys.append("dipoleFrequencyMHz");
     applySettings();
     ui->dipoleElementLength->blockSignals(true);
     ui->dipoleElementLength->setValue(value/2.0);
@@ -377,6 +401,7 @@ void AntennaToolsGUI::on_dipoleLength_valueChanged(double value)
 void AntennaToolsGUI::on_dipoleElementLength_valueChanged(double value)
 {
     m_settings.m_dipoleFrequencyMHz = calcDipoleFrequency(value*2.0);
+    m_settingsKeys.append("dipoleFrequencyMHz");
     applySettings();
     ui->dipoleLength->blockSignals(true);
     ui->dipoleLength->setValue(value*2.0);
@@ -468,6 +493,7 @@ void AntennaToolsGUI::calcDishEffectiveArea()
 void AntennaToolsGUI::on_dishFrequency_valueChanged(double value)
 {
     m_settings.m_dishFrequencyMHz = value;
+    m_settingsKeys.append("dishFrequencyMHz");
     applySettings();
     calcDishBeamwidth();
     calcDishGain();
@@ -477,6 +503,7 @@ void AntennaToolsGUI::on_dishFrequency_valueChanged(double value)
 void AntennaToolsGUI::on_dishFrequencySelect_currentIndexChanged(int index)
 {
     m_settings.m_dishFrequencySelect = index;
+    m_settingsKeys.append("dishFrequencySelect");
     applySettings();
     if (index >= 1)
     {
@@ -491,6 +518,7 @@ void AntennaToolsGUI::on_dishFrequencySelect_currentIndexChanged(int index)
 void AntennaToolsGUI::on_dishDiameter_valueChanged(double value)
 {
     m_settings.m_dishDiameter = value;
+    m_settingsKeys.append("dishDiameter");
     applySettings();
     calcDishFocalLength();
     calcDishBeamwidth();
@@ -501,6 +529,7 @@ void AntennaToolsGUI::on_dishDiameter_valueChanged(double value)
 void AntennaToolsGUI::on_dishLengthUnits_currentIndexChanged(int index)
 {
     m_settings.m_dishLengthUnits = (AntennaToolsSettings::LengthUnits)index;
+    m_settingsKeys.append("dishLengthUnits");
     applySettings();
     calcDishFocalLength();
     calcDishBeamwidth();
@@ -511,6 +540,7 @@ void AntennaToolsGUI::on_dishLengthUnits_currentIndexChanged(int index)
 void AntennaToolsGUI::on_dishDepth_valueChanged(double value)
 {
     m_settings.m_dishDepth = value;
+    m_settingsKeys.append("dishDepth");
     applySettings();
     calcDishFocalLength();
 }
@@ -518,6 +548,7 @@ void AntennaToolsGUI::on_dishDepth_valueChanged(double value)
 void AntennaToolsGUI::on_dishEfficiency_valueChanged(int value)
 {
     m_settings.m_dishEfficiency = value;
+    m_settingsKeys.append("dishEfficiency");
     applySettings();
     calcDishGain();
     calcDishEffectiveArea();
@@ -526,6 +557,7 @@ void AntennaToolsGUI::on_dishEfficiency_valueChanged(int value)
 void AntennaToolsGUI::on_dishSurfaceError_valueChanged(double value)
 {
     m_settings.m_dishSurfaceError= value;
+    m_settingsKeys.append("dishSurfaceError");
     applySettings();
     calcDishGain();
     calcDishEffectiveArea();

plugins/feature/antennatools/antennatoolsgui.h

@@ -56,6 +56,7 @@ private:
     PluginAPI* m_pluginAPI;
     FeatureUISet* m_featureUISet;
     AntennaToolsSettings m_settings;
+    QList<QString> m_settingsKeys;
     RollupState m_rollupState;
     bool m_doApplySettings;
 

plugins/feature/antennatools/antennatoolssettings.cpp

@@ -146,3 +146,126 @@ bool AntennaToolsSettings::deserialize(const QByteArray& data)
         return false;
     }
 }
+
+void AntennaToolsSettings::applySettings(const QStringList& settingsKeys, const AntennaToolsSettings& settings)
+{
+    if (settingsKeys.contains("dipoleFrequencyMHz")) {
+        m_dipoleFrequencyMHz = settings.m_dipoleFrequencyMHz;
+    }
+    if (settingsKeys.contains("dipoleFrequencySelect")) {
+        m_dipoleFrequencySelect = settings.m_dipoleFrequencySelect;
+    }
+    if (settingsKeys.contains("dipoleEndEffectFactor")) {
+        m_dipoleEndEffectFactor = settings.m_dipoleEndEffectFactor;
+    }
+    if (settingsKeys.contains("dipoleLengthUnits")) {
+        m_dipoleLengthUnits = settings.m_dipoleLengthUnits;
+    }
+    if (settingsKeys.contains("dishFrequencyMHz")) {
+        m_dishFrequencyMHz = settings.m_dishFrequencyMHz;
+    }
+    if (settingsKeys.contains("dishDiameter")) {
+        m_dishDiameter = settings.m_dishDiameter;
+    }
+    if (settingsKeys.contains("dishDepth")) {
+        m_dishDepth = settings.m_dishDepth;
+    }
+    if (settingsKeys.contains("dishEfficiency")) {
+        m_dishEfficiency = settings.m_dishEfficiency;
+    }
+    if (settingsKeys.contains("dishLengthUnits")) {
+        m_dishLengthUnits = settings.m_dishLengthUnits;
+    }
+    if (settingsKeys.contains("dishSurfaceError")) {
+        m_dishSurfaceError = settings.m_dishSurfaceError;
+    }
+    if (settingsKeys.contains("title")) {
+        m_title = settings.m_title;
+    }
+    if (settingsKeys.contains("rgbColor")) {
+        m_rgbColor = settings.m_rgbColor;
+    }
+    if (settingsKeys.contains("useReverseAPI")) {
+        m_useReverseAPI = settings.m_useReverseAPI;
+    }
+    if (settingsKeys.contains("reverseAPIAddress")) {
+        m_reverseAPIAddress = settings.m_reverseAPIAddress;
+    }
+    if (settingsKeys.contains("reverseAPIPort")) {
+        m_reverseAPIPort = settings.m_reverseAPIPort;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureSetIndex")) {
+        m_reverseAPIFeatureSetIndex = settings.m_reverseAPIFeatureSetIndex;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureIndex")) {
+        m_reverseAPIFeatureIndex = settings.m_reverseAPIFeatureIndex;
+    }
+    if (settingsKeys.contains("workspaceIndex")) {
+        m_workspaceIndex = settings.m_workspaceIndex;
+    }
+}
+
+QString AntennaToolsSettings::getDebugString(const QStringList& settingsKeys, bool force) const
+{
+    std::ostringstream ostr;
+
+    if (settingsKeys.contains("dipoleFrequencyMHz") || force) {
+        ostr << " m_dipoleFrequencyMHz: " << m_dipoleFrequencyMHz;
+    }
+    if (settingsKeys.contains("dipoleFrequencySelect") || force) {
+        ostr << " m_dipoleFrequencySelect: " << m_dipoleFrequencySelect;
+    }
+    if (settingsKeys.contains("dipoleEndEffectFactor") || force) {
+        ostr << " m_dipoleEndEffectFactor: " << m_dipoleEndEffectFactor;
+    }
+    if (settingsKeys.contains("dipoleLengthUnits") || force) {
+        ostr << " m_dipoleLengthUnits: " << m_dipoleLengthUnits;
+    }
+    if (settingsKeys.contains("dishFrequencyMHz") || force) {
+        ostr << " m_dishFrequencyMHz: " << m_dishFrequencyMHz;
+    }
+    if (settingsKeys.contains("dishFrequencySelect") || force) {
+        ostr << " m_dishFrequencySelect: " << m_dishFrequencySelect;
+    }
+    if (settingsKeys.contains("dishDiameter") || force) {
+        ostr << " m_dishDiameter: " << m_dishDiameter;
+    }
+    if (settingsKeys.contains("dishDepth") || force) {
+        ostr << " m_dishDepth: " << m_dishDepth;
+    }
+    if (settingsKeys.contains("dishEfficiency") || force) {
+        ostr << " m_dishEfficiency: " << m_dishEfficiency;
+    }
+    if (settingsKeys.contains("dishLengthUnits") || force) {
+        ostr << " m_dishLengthUnits: " << m_dishLengthUnits;
+    }
+    if (settingsKeys.contains("dishSurfaceError") || force) {
+        ostr << " m_dishSurfaceError: " << m_dishSurfaceError;
+    }
+    if (settingsKeys.contains("title") || force) {
+        ostr << " m_title: " << m_title.toStdString();
+    }
+    if (settingsKeys.contains("rgbColor") || force) {
+        ostr << " m_rgbColor: " << m_rgbColor;
+    }
+    if (settingsKeys.contains("useReverseAPI") || force) {
+        ostr << " m_useReverseAPI: " << m_useReverseAPI;
+    }
+    if (settingsKeys.contains("reverseAPIAddress") || force) {
+        ostr << " m_reverseAPIAddress: " << m_reverseAPIAddress.toStdString();
+    }
+    if (settingsKeys.contains("reverseAPIPort") || force) {
+        ostr << " m_reverseAPIPort: " << m_reverseAPIPort;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureSetIndex") || force) {
+        ostr << " m_reverseAPIFeatureSetIndex: " << m_reverseAPIFeatureSetIndex;
+    }
+    if (settingsKeys.contains("reverseAPIFeatureIndex") || force) {
+        ostr << " m_reverseAPIFeatureIndex: " << m_reverseAPIFeatureIndex;
+    }
+    if (settingsKeys.contains("workspaceIndex") || force) {
+        ostr << " m_workspaceIndex: " << m_workspaceIndex;
+    }
+
+    return QString(ostr.str().c_str());
+}

plugins/feature/antennatools/antennatoolssettings.h

@@ -59,6 +59,8 @@ struct AntennaToolsSettings
     QByteArray serialize() const;
     bool deserialize(const QByteArray& data);
     void setRollupState(Serializable *rollupState) { m_rollupState = rollupState; }
+    void applySettings(const QStringList& settingsKeys, const AntennaToolsSettings& settings);
+    QString getDebugString(const QStringList& settingsKeys, bool force=false) const;
 };
 
 #endif // INCLUDE_FEATURE_ANTENNATOOLSSETTINGS_H_