Updates in general was only done if a POI changed. This caused changes related...

Updates in general was only done if a POI changed. This caused changes related to something other than a change in POI to be ignore. The code now "resets" the POI when such changes occur (change of ruleset for example).
Ruleset selection is was not persistent. When reloading the list of rulesets for a given region, any previously selected ruleset would be reset to defaults.
Also fixed several new clang warnings.

src/Airmap/AirMapAdvisoryManager.cc

@@ -36,10 +36,10 @@ AirMapAdvisoryManager::AirMapAdvisoryManager(AirMapSharedState& shared, QObject
 
 //-----------------------------------------------------------------------------
 void
-AirMapAdvisoryManager::setROI(const QGCGeoBoundingCube& roi)
+AirMapAdvisoryManager::setROI(const QGCGeoBoundingCube& roi, bool reset)
 {
     //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates.
-    if(!_lastROI.isValid() || _lastROI.pointNW.distanceTo(roi.pointNW) > ADVISORY_UPDATE_DISTANCE || _lastROI.pointSE.distanceTo(roi.pointSE) > ADVISORY_UPDATE_DISTANCE) {
+    if(reset || (!_lastROI.isValid() || _lastROI.pointNW.distanceTo(roi.pointNW) > ADVISORY_UPDATE_DISTANCE || _lastROI.pointSE.distanceTo(roi.pointSE) > ADVISORY_UPDATE_DISTANCE)) {
         _lastROI = roi;
         _requestAdvisories();
     }
@@ -52,7 +52,7 @@ adv_sort(QObject* a, QObject* b)
     AirMapAdvisory* aa = qobject_cast<AirMapAdvisory*>(a);
     AirMapAdvisory* bb = qobject_cast<AirMapAdvisory*>(b);
     if(!aa || !bb) return false;
-    return (int)aa->color() > (int)bb->color();
+    return static_cast<int>(aa->color()) > static_cast<int>(bb->color());
 }
 
 //-----------------------------------------------------------------------------
@@ -69,12 +69,12 @@ AirMapAdvisoryManager::_requestAdvisories()
     _valid = false;
     _advisories.clearAndDeleteContents();
     Status::GetStatus::Parameters params;
-    params.longitude = _lastROI.center().longitude();
-    params.latitude  = _lastROI.center().latitude();
+    params.longitude = static_cast<float>(_lastROI.center().longitude());
+    params.latitude  = static_cast<float>(_lastROI.center().latitude());
     params.types     = Airspace::Type::all;
     params.weather   = false;
     double diagonal  = _lastROI.pointNW.distanceTo(_lastROI.pointSE);
-    params.buffer    = std::fmax(std::fmin(diagonal, 10000.0), 500.0);
+    params.buffer    = static_cast<std::uint32_t>(std::fmax(std::fmin(diagonal, 10000.0), 500.0));
     params.flight_date_time = Clock::universal_time();
     std::weak_ptr<LifetimeChecker> isAlive(_instance);
     _shared.client()->status().get_status_by_point(params, [this, isAlive](const Status::GetStatus::Result& result) {

src/Airmap/AirMapAdvisoryManager.h

@@ -57,7 +57,7 @@ public:
     bool                valid               () override { return _valid; }
     AdvisoryColor       airspaceColor       () override { return _airspaceColor; }
     QmlObjectListModel* advisories          () override { return &_advisories; }
-    void                setROI              (const QGCGeoBoundingCube& roi) override;
+    void                setROI              (const QGCGeoBoundingCube& roi, bool reset = false) override;
 signals:
     void                error               (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
 private:

src/Airmap/AirMapManager.cc

@@ -42,9 +42,9 @@ AirMapManager::AirMapManager(QGCApplication* app, QGCToolbox* toolbox)
 {
     _logger = std::make_shared<qt::Logger>();
     qt::register_types(); // TODO: still needed?
-    _logger->logging_category().setEnabled(QtDebugMsg,   true);
-    _logger->logging_category().setEnabled(QtInfoMsg,    true);
-    _logger->logging_category().setEnabled(QtWarningMsg, true);
+    _logger->logging_category().setEnabled(QtDebugMsg,   false);
+    _logger->logging_category().setEnabled(QtInfoMsg,    false);
+    _logger->logging_category().setEnabled(QtWarningMsg, false);
     _dispatchingLogger = std::make_shared<qt::DispatchingLogger>(_logger);
     connect(&_shared, &AirMapSharedState::error, this, &AirMapManager::_error);
 }
@@ -76,7 +76,7 @@ AirMapManager::setToolbox(QGCToolbox* toolbox)
 bool
 AirMapManager::connected() const
 {
-    return _shared.client() != NULL;
+    return _shared.client() != nullptr;
 }
 
 //-----------------------------------------------------------------------------

src/Airmap/AirMapManager.h

@@ -18,6 +18,8 @@
 
 #include <memory>
 
+#include <QTimer>
+
 class QGCToolbox;
 
 Q_DECLARE_LOGGING_CATEGORY(AirMapManagerLog)
@@ -33,7 +35,7 @@ class AirMapManager : public AirspaceManager
     Q_OBJECT
 public:
     AirMapManager(QGCApplication* app, QGCToolbox* toolbox);
-    virtual ~AirMapManager();
+    virtual ~AirMapManager() override;
 
     void setToolbox (QGCToolbox* toolbox) override;
 

src/Airmap/AirMapRestrictionManager.cc

@@ -25,10 +25,10 @@ AirMapRestrictionManager::AirMapRestrictionManager(AirMapSharedState& shared)
 
 //-----------------------------------------------------------------------------
 void
-AirMapRestrictionManager::setROI(const QGCGeoBoundingCube& roi)
+AirMapRestrictionManager::setROI(const QGCGeoBoundingCube& roi, bool reset)
 {
     //-- If first time or we've moved more than RESTRICTION_UPDATE_DISTANCE, ask for updates.
-    if(!_lastROI.isValid() || _lastROI.pointNW.distanceTo(roi.pointNW) > RESTRICTION_UPDATE_DISTANCE || _lastROI.pointSE.distanceTo(roi.pointSE) > RESTRICTION_UPDATE_DISTANCE) {
+    if(reset || (!_lastROI.isValid() || _lastROI.pointNW.distanceTo(roi.pointNW) > RESTRICTION_UPDATE_DISTANCE || _lastROI.pointSE.distanceTo(roi.pointSE) > RESTRICTION_UPDATE_DISTANCE)) {
         //-- No more than 40000 km^2
         if(roi.area() < 40000.0) {
             _lastROI = roi;
@@ -94,8 +94,12 @@ AirMapRestrictionManager::_requestRestrictions(const QGCGeoBoundingCube& roi)
                         // TODO: radius???
                     }
                         break;
+                    case Geometry::Type::invalid: {
+                        qWarning() << "Invalid geometry type";
+                    }
+                        break;
                     default:
-                        qWarning() << "unsupported geometry type: "<<(int)geometry.type();
+                        qWarning() << "Unsupported geometry type: " << static_cast<int>(geometry.type());
                         break;
                 }
             }

src/Airmap/AirMapRestrictionManager.h

@@ -31,7 +31,7 @@ public:
     AirMapRestrictionManager            (AirMapSharedState& shared);
     QmlObjectListModel* polygons        () override { return &_polygons; }
     QmlObjectListModel* circles         () override { return &_circles; }
-    void                setROI          (const QGCGeoBoundingCube &roi) override;
+    void                setROI          (const QGCGeoBoundingCube &roi, bool reset = false) override;
 
 signals:
     void error                          (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);

src/Airmap/AirMapRulesetsManager.cc

@@ -9,6 +9,7 @@
 
 #include "AirMapRulesetsManager.h"
 #include "AirMapManager.h"
+#include "QGCApplication.h"
 #include <QSettings>
 
 using namespace airmap;
@@ -193,11 +194,19 @@ void
 AirMapRuleSet::setSelected(bool sel)
 {
     if(_selectionType != AirspaceRuleSet::Required) {
-        _selected = sel;
+        if(_selected != sel) {
+            _selected = sel;
+            emit selectedChanged();
+            qDebug() << "Selection" << name() << sel;
+            qgcApp()->toolbox()->airspaceManager()->setUpdate();
+        }
     } else {
-        _selected = true;
+        if(!_selected) {
+            _selected = true;
+            emit selectedChanged();
+            qgcApp()->toolbox()->airspaceManager()->setUpdate();
+        }
     }
-    emit selectedChanged();
 }
 
 //-----------------------------------------------------------------------------
@@ -213,12 +222,13 @@ rules_sort(QObject* a, QObject* b)
     AirMapRule* aa = qobject_cast<AirMapRule*>(a);
     AirMapRule* bb = qobject_cast<AirMapRule*>(b);
     if(!aa || !bb) return false;
-    return (int)aa->order() > (int)bb->order();
+    return static_cast<int>(aa->order()) > static_cast<int>(bb->order());
 }
 
 //-----------------------------------------------------------------------------
-void AirMapRulesetsManager::setROI(const QGCGeoBoundingCube& roi)
+void AirMapRulesetsManager::setROI(const QGCGeoBoundingCube& roi, bool reset)
 {
+    Q_UNUSED(reset);
     if (!_shared.client()) {
         qCDebug(AirMapManagerLog) << "No AirMap client instance. Not updating Airspace";
         return;
@@ -229,6 +239,13 @@ void AirMapRulesetsManager::setROI(const QGCGeoBoundingCube& roi)
     }
     qCDebug(AirMapManagerLog) << "Rulesets Request (ROI Changed)";
     _valid = false;
+    //-- Save current selection state
+    QMap<QString, bool> selectionSet;
+    for(int rs = 0; rs < ruleSets()->count(); rs++) {
+        AirMapRuleSet* ruleSet = qobject_cast<AirMapRuleSet*>(ruleSets()->get(rs));
+        selectionSet[ruleSet->id()] = ruleSet->selected();
+        qDebug() << ruleSet->id() << ruleSet->selected();
+    }
     _ruleSets.clearAndDeleteContents();
     _state = State::RetrieveItems;
     RuleSets::Search::Parameters params;
@@ -243,7 +260,7 @@ void AirMapRulesetsManager::setROI(const QGCGeoBoundingCube& roi)
     params.geometry = Geometry(polygon);
     std::weak_ptr<LifetimeChecker> isAlive(_instance);
     _shared.client()->rulesets().search(params,
-            [this, isAlive](const RuleSets::Search::Result& result) {
+            [this, isAlive, selectionSet](const RuleSets::Search::Result& result) {
         if (!isAlive.lock()) return;
         if (_state != State::RetrieveItems) return;
         if (result) {
@@ -257,10 +274,14 @@ void AirMapRulesetsManager::setROI(const QGCGeoBoundingCube& roi)
                 pRuleSet->_shortName   = QString::fromStdString(ruleset.short_name);
                 pRuleSet->_description = QString::fromStdString(ruleset.description);
                 pRuleSet->_isDefault   = ruleset.is_default;
-                //-- TODO: This should be persistent and if the new incoming set has the
-                //   same, previosuly selected rulesets, it should "remember".
-                if(pRuleSet->_isDefault) {
-                    pRuleSet->_selected = true;
+                //-- Restore selection set (if any)
+                if(selectionSet.contains(pRuleSet->id())) {
+                    pRuleSet->_selected = selectionSet[pRuleSet->id()];
+                    qDebug() << pRuleSet->name() << pRuleSet->id() << pRuleSet->_selected;
+                } else {
+                    if(pRuleSet->_isDefault) {
+                        pRuleSet->_selected = true;
+                    }
                 }
                 switch(ruleset.selection_type) {
                 case RuleSet::SelectionType::pickone:
@@ -270,7 +291,6 @@ void AirMapRulesetsManager::setROI(const QGCGeoBoundingCube& roi)
                     pRuleSet->_selectionType = AirspaceRuleSet::Required;
                     pRuleSet->_selected = true;
                     break;
-                default:
                 case RuleSet::SelectionType::optional:
                     pRuleSet->_selectionType = AirspaceRuleSet::Optional;
                     break;
@@ -356,3 +376,14 @@ AirMapRulesetsManager::_selectedChanged()
     emit selectedRuleSetsChanged();
     //-- TODO: Do whatever it is you do to select a rule
 }
+
+//-----------------------------------------------------------------------------
+void
+AirMapRulesetsManager::clearAllFeatures()
+{
+    QSettings settings;
+    settings.beginGroup(kAirMapFeatureGroup);
+    settings.remove("");
+    settings.endGroup();
+}
+

src/Airmap/AirMapRulesetsManager.h

@@ -30,10 +30,10 @@ class AirMapRuleFeature : public AirspaceRuleFeature
     Q_OBJECT
 public:
 
-    AirMapRuleFeature(QObject* parent = NULL);
-    AirMapRuleFeature(airmap::RuleSet::Feature feature, QObject* parent = NULL);
+    AirMapRuleFeature(QObject* parent = nullptr);
+    AirMapRuleFeature(airmap::RuleSet::Feature feature, QObject* parent = nullptr);
 
-    quint32         id              () override { return (quint32)_feature.id; }
+    quint32         id              () override { return static_cast<quint32>(_feature.id); }
     Type            type            () override;
     Unit            unit            () override;
     Measurement     measurement     () override;
@@ -54,11 +54,11 @@ class AirMapRule : public AirspaceRule
     friend class AirMapFlightPlanManager;
 public:
 
-    AirMapRule  (QObject* parent = NULL);
-    AirMapRule  (const airmap::RuleSet::Rule& rule, QObject* parent = NULL);
-    ~AirMapRule ();
+    AirMapRule  (QObject* parent = nullptr);
+    AirMapRule  (const airmap::RuleSet::Rule& rule, QObject* parent = nullptr);
+    ~AirMapRule () override;
 
-    int                 order           () { return (int)_rule.display_order; }
+    int                 order           () { return static_cast<int>(_rule.display_order); }
     Status              status          () override;
     QString             shortText       () override { return QString::fromStdString(_rule.short_text);  }
     QString             description     () override { return QString::fromStdString(_rule.description); }
@@ -76,8 +76,8 @@ class AirMapRuleSet : public AirspaceRuleSet
     friend class AirMapRulesetsManager;
     friend class AirMapFlightPlanManager;
 public:
-    AirMapRuleSet                   (QObject* parent = NULL);
-    ~AirMapRuleSet                  ();
+    AirMapRuleSet                   (QObject* parent = nullptr);
+    ~AirMapRuleSet                  () override;
     QString         id              () override { return _id; }
     QString         description     () override { return _description; }
     bool            isDefault       () override { return _isDefault; }
@@ -109,7 +109,8 @@ public:
     QmlObjectListModel* ruleSets    () override { return &_ruleSets; }
     QString         selectedRuleSets() override;
 
-    void                setROI      (const QGCGeoBoundingCube& roi) override;
+    void                setROI      (const QGCGeoBoundingCube& roi, bool reset = false) override;
+    void            clearAllFeatures() override;
 
 signals:
     void        error               (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
@@ -125,7 +126,7 @@ private:
     bool                            _valid;
     State                           _state = State::Idle;
     AirMapSharedState&              _shared;
-    QmlObjectListModel              _ruleSets;
+    QmlObjectListModel              _ruleSets;  //-- List of AirMapRuleSet elements
 };
 
 

src/Airmap/AirMapWeatherInfoManager.cc

@@ -24,10 +24,10 @@ AirMapWeatherInfoManager::AirMapWeatherInfoManager(AirMapSharedState& shared, QO
 }
 
 void
-AirMapWeatherInfoManager::setROI(const QGCGeoBoundingCube& roi)
+AirMapWeatherInfoManager::setROI(const QGCGeoBoundingCube& roi, bool reset)
 {
     //-- If first time or we've moved more than WEATHER_UPDATE_DISTANCE, ask for weather updates.
-    if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(roi.center()) > WEATHER_UPDATE_DISTANCE) {
+    if(reset || (!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(roi.center()) > WEATHER_UPDATE_DISTANCE)) {
         _lastRoiCenter = roi.center();
         _requestWeatherUpdate(_lastRoiCenter);
         _weatherTime.start();

src/Airmap/AirMapWeatherInfoManager.h

@@ -42,7 +42,7 @@ public:
     float       visibility      () override { return _weather.visibility; }
     float       precipitation   () override { return _weather.precipitation; }
 
-    void        setROI          (const QGCGeoBoundingCube& roi) override;
+    void        setROI          (const QGCGeoBoundingCube& roi, bool reset = false) override;
 
 signals:
     void        error           (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);

src/Airmap/dummy/AirspaceManager.cc

@@ -26,9 +26,10 @@ void AirspaceManager::setToolbox(QGCToolbox* toolbox)
     QGCTool::setToolbox(toolbox);
 }
 
-void AirspaceManager::setROI(const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView)
+void AirspaceManager::setROI(const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView, bool reset)
 {
     Q_UNUSED(pointNW);
     Q_UNUSED(pointSE);
     Q_UNUSED(planView);
+    Q_UNUSED(reset)
 }

src/Airmap/dummy/AirspaceManager.h

@@ -26,7 +26,7 @@ class AirspaceManager : public QGCTool {
     Q_OBJECT
 public:
     AirspaceManager(QGCApplication* app, QGCToolbox* toolbox);
-    virtual ~AirspaceManager();
+    virtual ~AirspaceManager() override;
 
     Q_PROPERTY(QString                      providerName        READ providerName       CONSTANT)
     Q_PROPERTY(QObject*                     weatherInfo         READ weatherInfo        CONSTANT)
@@ -36,7 +36,7 @@ public:
     Q_PROPERTY(QObject*                     flightPlan          READ flightPlan         CONSTANT)
     Q_PROPERTY(bool                         airspaceVisible     READ airspaceVisible    CONSTANT)
 
-    Q_INVOKABLE void setROI                     (const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView);
+    Q_INVOKABLE void setROI                     (const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView, bool reset = false);
 
     QObject*                    weatherInfo    () { return &_dummy; }
     QObject*                    advisories     () { return &_dummy; }

src/AirspaceManagement/AirspaceAdvisoryProvider.h

@@ -50,7 +50,7 @@ public:
      * Set region of interest that should be queried. When finished, the advisoryChanged() signal will be emmited.
      * @param center Center coordinate for ROI
      */
-    virtual void setROI (const QGCGeoBoundingCube& roi) = 0;
+    virtual void setROI (const QGCGeoBoundingCube& roi, bool reset = false) = 0;
 
 signals:
     void advisoryChanged  ();

src/AirspaceManagement/AirspaceManager.cc

@@ -22,13 +22,17 @@
 
 QGC_LOGGING_CATEGORY(AirspaceManagementLog, "AirspaceManagementLog")
 
+//-----------------------------------------------------------------------------
 AirspaceManager::AirspaceManager(QGCApplication* app, QGCToolbox* toolbox)
     : QGCTool(app, toolbox)
     , _airspaceVisible(false)
 {
     _roiUpdateTimer.setInterval(2000);
     _roiUpdateTimer.setSingleShot(true);
-    connect(&_roiUpdateTimer, &QTimer::timeout, this, &AirspaceManager::_updateToROI);
+    _updateTimer.setInterval(1000);
+    _updateTimer.setSingleShot(true);
+    connect(&_roiUpdateTimer, &QTimer::timeout, this, &AirspaceManager::_updateToROITimeout);
+    connect(&_updateTimer,    &QTimer::timeout, this, &AirspaceManager::_updateTimeout);
     qmlRegisterUncreatableType<AirspaceAdvisoryProvider>    ("QGroundControl.Airspace",      1, 0, "AirspaceAdvisoryProvider",       "Reference only");
     qmlRegisterUncreatableType<AirspaceFlightPlanProvider>  ("QGroundControl.Airspace",      1, 0, "AirspaceFlightPlanProvider",     "Reference only");
     qmlRegisterUncreatableType<AirspaceManager>             ("QGroundControl.Airspace",      1, 0, "AirspaceManager",                "Reference only");
@@ -42,6 +46,7 @@ AirspaceManager::AirspaceManager(QGCApplication* app, QGCToolbox* toolbox)
     qmlRegisterUncreatableType<AirspaceFlightInfo>          ("QGroundControl.Airspace",      1, 0, "AirspaceFlightInfo",             "Reference only");
 }
 
+//-----------------------------------------------------------------------------
 AirspaceManager::~AirspaceManager()
 {
     if(_advisories) {
@@ -61,7 +66,9 @@ AirspaceManager::~AirspaceManager()
     }
 }
 
-void AirspaceManager::setToolbox(QGCToolbox* toolbox)
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::setToolbox(QGCToolbox* toolbox)
 {
     QGCTool::setToolbox(toolbox);
     // We should not call virtual methods in the constructor, so we instantiate the restriction provider here
@@ -72,23 +79,45 @@ void AirspaceManager::setToolbox(QGCToolbox* toolbox)
     _flightPlan         = _instantiateAirspaceFlightPlanProvider();
 }
 
-void AirspaceManager::setROI(const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView)
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::setROI(const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView, bool reset)
 {
     if(planView) {
         //-- Is there a mission?
         if(_flightPlan->flightPermitStatus() != AirspaceFlightPlanProvider::PermitNone) {
             //-- Is there a polygon to work with?
             if(_flightPlan->missionArea()->isValid() && _flightPlan->missionArea()->area() > 0.0) {
-                _setROI(*_flightPlan->missionArea());
+                if(reset) {
+                    _roi = *_flightPlan->missionArea();
+                    _updateToROI(true);
+                } else {
+                    _setROI(*_flightPlan->missionArea());
+                }
                 return;
             }
         }
     }
     //-- Use screen coordinates (what you see is what you get)
-    _setROI(QGCGeoBoundingCube(pointNW, pointSE));
+    if(reset) {
+        _roi = QGCGeoBoundingCube(pointNW, pointSE);
+        _updateToROI(true);
+    } else {
+        _setROI(QGCGeoBoundingCube(pointNW, pointSE));
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::setUpdate()
+{
+    _updateTimer.start();
 }
 
-void AirspaceManager::_setROI(const QGCGeoBoundingCube& roi)
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::_setROI(const QGCGeoBoundingCube& roi)
 {
     if(_roi != roi) {
         _roi = roi;
@@ -96,18 +125,37 @@ void AirspaceManager::_setROI(const QGCGeoBoundingCube& roi)
     }
 }
 
-void AirspaceManager::_updateToROI()
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::_updateToROI(bool reset)
 {
+    if(reset) {
+        _updateTimer.stop();
+    }
     if(_airspaces) {
-        _airspaces->setROI(_roi);
+        _airspaces->setROI(_roi, reset);
     }
     if(_ruleSetsProvider) {
-        _ruleSetsProvider->setROI(_roi);
+        _ruleSetsProvider->setROI(_roi, reset);
     }
     if(_weatherProvider) {
-        _weatherProvider->setROI(_roi);
+        _weatherProvider->setROI(_roi, reset);
     }
     if (_advisories) {
-        _advisories->setROI(_roi);
+        _advisories->setROI(_roi, reset);
     }
 }
+
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::_updateToROITimeout()
+{
+    _updateToROI(false);
+}
+
+//-----------------------------------------------------------------------------
+void
+AirspaceManager::_updateTimeout()
+{
+    emit update();
+}

src/AirspaceManagement/AirspaceManager.h

@@ -55,7 +55,7 @@ class AirspaceManager : public QGCTool {
     Q_OBJECT
 public:
     AirspaceManager(QGCApplication* app, QGCToolbox* toolbox);
-    virtual ~AirspaceManager();
+    virtual ~AirspaceManager() override;
 
     Q_PROPERTY(QString                      providerName        READ providerName       CONSTANT)
     Q_PROPERTY(AirspaceWeatherInfoProvider* weatherInfo         READ weatherInfo        CONSTANT)
@@ -67,7 +67,7 @@ public:
     Q_PROPERTY(QString                      connectStatus       READ connectStatus      NOTIFY connectStatusChanged)
     Q_PROPERTY(bool                         airspaceVisible     READ airspaceVisible    WRITE setAirspaceVisible    NOTIFY airspaceVisibleChanged)
 
-    Q_INVOKABLE void setROI                     (const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView);
+    Q_INVOKABLE void setROI                     (const QGeoCoordinate& pointNW, const QGeoCoordinate& pointSE, bool planView, bool reset = false);
 
     AirspaceWeatherInfoProvider* weatherInfo    () { return _weatherProvider; }
     AirspaceAdvisoryProvider*    advisories     () { return _advisories; }
@@ -83,6 +83,7 @@ public:
     virtual void             setAirspaceVisible (bool set) { _airspaceVisible = set; emit airspaceVisibleChanged(); }
     virtual bool                connected       () const = 0;
     virtual QString             connectStatus   () const { return QString(); }
+    virtual void                setUpdate       ();
 
     /**
      * Factory method to create an AirspaceVehicleManager object
@@ -93,6 +94,7 @@ signals:
     void                airspaceVisibleChanged  ();
     void                connectedChanged        ();
     void                connectStatusChanged    ();
+    void                update                  ();
 
 protected:
     /**
@@ -119,9 +121,14 @@ protected:
     AirspaceRestrictionProvider*    _airspaces              = nullptr; ///< Airspace info
     AirspaceFlightPlanProvider*     _flightPlan             = nullptr; ///< Flight plan management
     QTimer                          _roiUpdateTimer;
+    QTimer                          _updateTimer;
     QGCGeoBoundingCube              _roi;
 
+private slots:
+    void _updateToROITimeout        ();
+    void _updateTimeout             ();
+
 private:
-    void _updateToROI   ();
+    void _updateToROI               (bool reset = false);
 
 };

src/AirspaceManagement/AirspaceRestrictionProvider.h

@@ -38,7 +38,7 @@ public:
      * @param center Center coordinate for ROI
      * @param radiusMeters Radius in meters around center which is of interest
      */
-    virtual void setROI (const QGCGeoBoundingCube& roi) = 0;
+    virtual void setROI (const QGCGeoBoundingCube& roi, bool reset = false) = 0;
 
     virtual QmlObjectListModel* polygons        () = 0;     ///< List of AirspacePolygonRestriction objects
     virtual QmlObjectListModel* circles         () = 0;     ///< List of AirspaceCircularRestriction objects

src/AirspaceManagement/AirspaceRulesetsProvider.h

@@ -52,7 +52,7 @@ public:
     Q_ENUM(Measurement)
     Q_ENUM(Unit)
 
-    AirspaceRuleFeature(QObject* parent = NULL);
+    AirspaceRuleFeature(QObject* parent = nullptr);
 
     Q_PROPERTY(quint32          id              READ id             CONSTANT)
     Q_PROPERTY(Type             type            READ type           CONSTANT)
@@ -91,7 +91,7 @@ public:
 
     Q_ENUM(Status)
 
-    AirspaceRule(QObject* parent = NULL);
+    AirspaceRule(QObject* parent = nullptr);
 
     Q_PROPERTY(Status               status          READ status         CONSTANT)
     Q_PROPERTY(QString              shortText       READ shortText      CONSTANT)
@@ -118,7 +118,7 @@ public:
 
     Q_ENUM(SelectionType)
 
-    AirspaceRuleSet(QObject* parent = NULL);
+    AirspaceRuleSet(QObject* parent = nullptr);
 
     Q_PROPERTY(QString          id              READ id             CONSTANT)
     Q_PROPERTY(QString          name            READ name           CONSTANT)
@@ -148,13 +148,15 @@ signals:
 class AirspaceRulesetsProvider : public QObject {
     Q_OBJECT
 public:
-    AirspaceRulesetsProvider        (QObject* parent = NULL);
+    AirspaceRulesetsProvider        (QObject* parent = nullptr);
     ~AirspaceRulesetsProvider       () = default;
 
     Q_PROPERTY(bool                 valid               READ valid              NOTIFY ruleSetsChanged)
     Q_PROPERTY(QString              selectedRuleSets    READ selectedRuleSets   NOTIFY selectedRuleSetsChanged)
     Q_PROPERTY(QmlObjectListModel*  ruleSets            READ ruleSets           NOTIFY ruleSetsChanged)
 
+    Q_INVOKABLE virtual void    clearAllFeatures() {;}          ///< Clear all saved (persistent) feature values
+
     virtual bool                valid       () = 0;             ///< Current ruleset is valid
     virtual QmlObjectListModel* ruleSets    () = 0;             ///< List of AirspaceRuleSet
     virtual QString         selectedRuleSets() = 0;             ///< All selected rules concatenated into a string
@@ -162,7 +164,7 @@ public:
      * Set region of interest that should be queried. When finished, the rulesChanged() signal will be emmited.
      * @param center Center coordinate for ROI
      */
-    virtual void        setROI      (const QGCGeoBoundingCube& roi) = 0;
+    virtual void        setROI      (const QGCGeoBoundingCube& roi, bool reset = false) = 0;
 
 signals:
     void ruleSetsChanged            ();

src/AirspaceManagement/AirspaceWeatherInfoProvider.h

@@ -51,7 +51,7 @@ public:
      * Set region of interest that should be queried. When finished, the weatherChanged() signal will be emmited.
      * @param center Center coordinate for ROI
      */
-    virtual void setROI (const QGCGeoBoundingCube& roi) = 0;
+    virtual void setROI (const QGCGeoBoundingCube& roi, bool reset = false) = 0;
 
 signals:
     void weatherChanged  ();

src/FlightDisplay/FlightDisplayViewMap.qml

@@ -56,12 +56,12 @@ FlightMap {
     property bool   _disableVehicleTracking:    false
     property bool   _keepVehicleCentered:       _mainIsMap ? false : true
 
-    function updateAirspace() {
+    function updateAirspace(reset) {
         if(_airspaceEnabled) {
             var coordinateNW = flightMap.toCoordinate(Qt.point(0,0), false /* clipToViewPort */)
             var coordinateSE = flightMap.toCoordinate(Qt.point(width,height), false /* clipToViewPort */)
             if(coordinateNW.isValid && coordinateSE.isValid) {
-                QGroundControl.airspaceManager.setROI(coordinateNW, coordinateSE, false /*planView*/)
+                QGroundControl.airspaceManager.setROI(coordinateNW, coordinateSE, false /*planView*/, reset)
             }
         }
     }
@@ -70,11 +70,11 @@ FlightMap {
 
     onZoomLevelChanged: {
         QGroundControl.flightMapZoom = zoomLevel
-        updateAirspace()
+        updateAirspace(false)
     }
     onCenterChanged: {
         QGroundControl.flightMapPosition = center
-        updateAirspace()
+        updateAirspace(false)
     }
 
     // When the user pans the map we stop responding to vehicle coordinate updates until the panRecenterTimer fires
@@ -88,7 +88,7 @@ FlightMap {
     }
 
     on_AirspaceEnabledChanged: {
-        updateAirspace()
+        updateAirspace(true)
     }
 
     function pointInRect(point, rect) {
@@ -166,6 +166,13 @@ FlightMap {
     QGCPalette { id: qgcPal; colorGroupEnabled: true }
     QGCMapPalette { id: mapPal; lightColors: isSatelliteMap }
 
+    Connections {
+        target: QGroundControl.airspaceManager
+        onUpdate: {
+            updateAirspace(true)
+        }
+    }
+
     Connections {
         target: _missionController
 

src/PlanView/PlanView.qml

@@ -89,12 +89,12 @@ QGCView {
         _missionController.setCurrentPlanViewIndex(sequenceNumber, true)
     }
 
-    function updateAirspace() {
+    function updateAirspace(reset) {
         if(_airspaceEnabled) {
             var coordinateNW = editorMap.toCoordinate(Qt.point(0,0), false /* clipToViewPort */)
             var coordinateSE = editorMap.toCoordinate(Qt.point(width,height), false /* clipToViewPort */)
             if(coordinateNW.isValid && coordinateSE.isValid) {
-                QGroundControl.airspaceManager.setROI(coordinateNW, coordinateSE, true /*planView*/)
+                QGroundControl.airspaceManager.setROI(coordinateNW, coordinateSE, true /*planView*/, reset)
             }
         }
     }
@@ -115,7 +115,7 @@ QGCView {
         if(QGroundControl.airmapSupported) {
             if(_airspaceEnabled) {
                 planControlColapsed = QGroundControl.airspaceManager.airspaceVisible
-                updateAirspace()
+                updateAirspace(true)
             } else {
                 planControlColapsed = false
             }
@@ -185,6 +185,9 @@ QGCView {
         onAirspaceVisibleChanged: {
             planControlColapsed = QGroundControl.airspaceManager.airspaceVisible
         }
+        onUpdate: {
+            updateAirspace(true)
+        }
     }
 
     Component {
@@ -469,8 +472,8 @@ QGCView {
 
             QGCMapPalette { id: mapPal; lightColors: editorMap.isSatelliteMap }
 
-            onZoomLevelChanged: updateAirspace()
-            onCenterChanged:    updateAirspace()
+            onZoomLevelChanged: updateAirspace(false)
+            onCenterChanged:    updateAirspace(false)
 
             MouseArea {
                 //-- It's a whole lot faster to just fill parent and deal with top offset below