Users can select multiple rules concurrently. In addition, some are mutually...

Users can select multiple rules concurrently. In addition, some are mutually exclusive. Add logic to handle this.

src/Airmap/AirMapRulesetsManager.cc

@@ -39,8 +39,6 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
         return;
     }
     qCDebug(AirMapManagerLog) << "Setting ROI for Rulesets";
-    _defaultIndex = 0;
-    _currentIndex = 0;
     _valid = false;
     _rules.clearAndDeleteContents();
     _state = State::RetrieveItems;
@@ -56,16 +54,16 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
             qCDebug(AirMapManagerLog) << "Successful rulesets search. Items:" << rules.size();
             for (const auto& ruleset : rules) {
                 AirMapRule* pRule = new AirMapRule(this);
+                connect(pRule, &AirspaceRule::selectedChanged, this, &AirMapRulesetsManager::_selectedChanged);
                 pRule->_id          = QString::fromStdString(ruleset.id);
                 pRule->_name        = QString::fromStdString(ruleset.name);
                 pRule->_shortName   = QString::fromStdString(ruleset.short_name);
                 pRule->_description = QString::fromStdString(ruleset.description);
                 pRule->_isDefault   = ruleset.is_default;
+                //-- TODO: This should be persistent and if the new incoming set has the
+                //   same, previosuly selected rules, it should "remember".
                 if(pRule->_isDefault) {
-                    _defaultIndex = _rules.count();
-                    //-- TODO: This should be persistent and if the new incoming set has this
-                    //   rule, it should point to it.
-                    _currentIndex = _defaultIndex;
+                    pRule->_selected = true;
                 }
                 switch(ruleset.selection_type) {
                 case RuleSet::SelectionType::pickone:
@@ -115,29 +113,32 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center)
         }
         _state = State::Idle;
         emit rulesChanged();
+        emit selectedRulesChanged();
     });
 }
 
 //-----------------------------------------------------------------------------
 QString
-AirMapRulesetsManager::defaultRule()
+AirMapRulesetsManager::selectedRules()
 {
-    if(_defaultIndex < _rules.count()) {
-        AirMapRule* rule = qobject_cast<AirMapRule*>(_rules.get(_defaultIndex));
-        if(rule) {
-            return rule->name();
+    QString selection;
+    for(int i = 0; i < _rules.count(); i++) {
+        AirMapRule* rule = qobject_cast<AirMapRule*>(_rules.get(i));
+        if(rule && rule->selected()) {
+            selection += rule->shortName() + ", ";
         }
     }
-    return QString();
+    int idx = selection.lastIndexOf(", ");
+    if(idx >= 0) {
+        selection = selection.left(idx);
+    }
+    return selection;
 }
 
 //-----------------------------------------------------------------------------
 void
-AirMapRulesetsManager::setCurrentIndex(int index)
+AirMapRulesetsManager::_selectedChanged()
 {
-    _currentIndex = index;
+    emit selectedRulesChanged();
     //-- TODO: Do whatever it is you do to select a rule
-
-
-    emit currentIndexChanged();
 }

src/Airmap/AirMapRulesetsManager.h

@@ -56,23 +56,21 @@ public:
 
     bool                valid       () override { return _valid; }
     QmlObjectListModel* rules       () override { return &_rules; }
-    QString             defaultRule () override;
-    int                 defaultIndex() override { return _defaultIndex; }
-    int                 currentIndex() override { return _currentIndex; }
-    void             setCurrentIndex(int index) override;
+    QString            selectedRules() override;
 
     void                setROI      (const QGeoCoordinate& center) override;
 
 signals:
-    void        error           (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
+    void        error               (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails);
+
+private slots:
+    void        _selectedChanged    ();
 
 private:
     enum class State {
         Idle,
         RetrieveItems,
     };
-    int                             _defaultIndex;
-    int                             _currentIndex;
     bool                            _valid;
     State                           _state = State::Idle;
     AirMapSharedState&              _shared;

src/Airmap/AirspaceControl.qml

@@ -279,16 +279,21 @@ Item {
                                 }
                                 Rectangle {
                                     id:                     regButton
-                                    height:                 regLabel.height + ScreenTools.defaultFontPixelHeight * 0.5
+                                    height:                 ScreenTools.defaultFontPixelHeight * 1.5
                                     radius:                 2
                                     color:                  _colorMidBrown
                                     Layout.fillWidth:       true
                                     QGCLabel {
-                                        id:                 regLabel
-                                        text:               _validRules ? _activeVehicle.airspaceController.rulesets.rules.get(currentIndex).name : qsTr("None")
-                                        color:              _colorWhite
-                                        anchors.centerIn:   parent
-                                        property int    currentIndex:   _validRules ? _activeVehicle.airspaceController.rulesets.currentIndex : 0
+                                        id:                     regLabel
+                                        text:                   _validRules ? _activeVehicle.airspaceController.rulesets.selectedRules : qsTr("None")
+                                        elide:                  Text.ElideRight
+                                        horizontalAlignment:    Text.AlignHCenter
+                                        color:                  _colorWhite
+                                        anchors.left:           parent.left
+                                        anchors.leftMargin:     ScreenTools.defaultFontPixelWidth  * 0.5
+                                        anchors.right:          parent.right
+                                        anchors.rightMargin:    ScreenTools.defaultFontPixelWidth  * 0.5
+                                        anchors.verticalCenter: parent.verticalCenter
                                     }
                                 }
                             }
@@ -408,6 +413,7 @@ Item {
                                 width:  1
                                 height: 1
                             }
+                            ExclusiveGroup { id: rulesGroup }
                             QGCLabel {
                                 text:           qsTr("PICK ONE REGULATION")
                                 font.pointSize: ScreenTools.smallFontPointSize
@@ -418,6 +424,7 @@ Item {
                                 delegate: RuleSelector {
                                     visible:             object.selectionType === AirspaceRule.Pickone
                                     rule:                object
+                                    exclusiveGroup:      rulesGroup
                                     anchors.right:       parent.right
                                     anchors.rightMargin: ScreenTools.defaultFontPixelWidth
                                     anchors.left:        parent.left
@@ -479,7 +486,7 @@ Item {
             }
             DropShadow {
                 anchors.fill:       arrowIconShadow
-                visible:            ruleSelectorRect.visible
+                visible:            ruleSelectorRect.visible && qgcPal.globalTheme === QGCPalette.Dark
                 horizontalOffset:   4
                 verticalOffset:     4
                 radius:             32.0

src/Airmap/RuleSelector.qml

@@ -12,9 +12,28 @@ import QGroundControl.Airmap            1.0
 import QGroundControl.SettingsManager   1.0
 
 Rectangle {
-    height:                 ScreenTools.defaultFontPixelHeight * 1.25
-    color:                  rule && rule.selected ? qgcPal.windowShadeDark : qgcPal.window
-    property var rule:      null
+    id:                         _root
+    height:                     ScreenTools.defaultFontPixelHeight
+    color:                      _selected ? qgcPal.windowShade : qgcPal.window
+    property var    rule:       null
+    property bool   checked:    false
+    property bool   _selected: {
+        if (exclusiveGroup) {
+            return checked
+        } else {
+            return rule ? rule.selected : false
+        }
+    }
+    property ExclusiveGroup exclusiveGroup:  null
+    onExclusiveGroupChanged: {
+        if (exclusiveGroup) {
+            checked = rule.selected
+            exclusiveGroup.bindCheckable(_root)
+        }
+    }
+    onCheckedChanged: {
+        rule.selected = checked
+    }
     QGCPalette {
         id: qgcPal
         colorGroupEnabled: enabled
@@ -28,7 +47,7 @@ Rectangle {
         Rectangle {
             width:      ScreenTools.defaultFontPixelWidth * 0.75
             height:     ScreenTools.defaultFontPixelHeight
-            color:      rule.selected ? qgcPal.colorGreen : qgcPal.window
+            color:      _selected ? qgcPal.colorGreen : qgcPal.window
             anchors.verticalCenter: parent.verticalCenter
         }
         QGCLabel {
@@ -40,7 +59,11 @@ Rectangle {
     MouseArea {
         anchors.fill: parent
         onClicked: {
-            rule.selected = !rule.selected
+            if (exclusiveGroup) {
+                checked = true
+            } else {
+                rule.selected = !rule.selected
+            }
         }
     }
 }

src/AirspaceManagement/AirspaceRulesetsProvider.h

@@ -66,17 +66,12 @@ public:
     ~AirspaceRulesetsProvider       () = default;
 
     Q_PROPERTY(bool                 valid           READ valid          NOTIFY rulesChanged)
-    Q_PROPERTY(QString              defaultRule     READ defaultRule    NOTIFY rulesChanged)
-    Q_PROPERTY(int                  defaultIndex    READ defaultIndex   NOTIFY rulesChanged)
-    Q_PROPERTY(int                  currentIndex    READ currentIndex   WRITE  setCurrentIndex NOTIFY currentIndexChanged)
+    Q_PROPERTY(QString              selectedRules   READ selectedRules  NOTIFY selectedRulesChanged)
     Q_PROPERTY(QmlObjectListModel*  rules           READ rules          NOTIFY rulesChanged)
 
     virtual bool                valid       () = 0;             ///< Current ruleset is valid
     virtual QmlObjectListModel* rules       () = 0;             ///< List of AirspaceRule
-    virtual QString             defaultRule () = 0;             ///< AirspaceRule::name
-    virtual int                 defaultIndex() = 0;             ///< Index into rules (QmlObjectListModel)
-    virtual int                 currentIndex() = 0;             ///< User selected index into rules (QmlObjectListModel)
-    virtual void             setCurrentIndex(int index) = 0;    ///< Select a rule
+    virtual QString            selectedRules() = 0;             ///< All selected rules concatenated into a string
     /**
      * Set region of interest that should be queried. When finished, the rulesChanged() signal will be emmited.
      * @param center Center coordinate for ROI
@@ -85,6 +80,6 @@ public:
 
 signals:
     void rulesChanged               ();
-    void currentIndexChanged        ();
+    void selectedRulesChanged       ();
 };