diff --git a/src/Airmap/AirMapAdvisoryManager.cc b/src/Airmap/AirMapAdvisoryManager.cc index 76e8860150636110beaedcbc39e75d64e6ad1044..2d232ffcbdd130eed02cf712ccd02c3105bcc5bf 100644 --- a/src/Airmap/AirMapAdvisoryManager.cc +++ b/src/Airmap/AirMapAdvisoryManager.cc @@ -8,8 +8,13 @@ ****************************************************************************/ #include "AirMapAdvisoryManager.h" +#include "AirspaceRestriction.h" #include "AirMapManager.h" +#include + +#include "airmap/airspaces.h" + #define ADVISORY_UPDATE_DISTANCE 500 //-- 500m threshold for updates using namespace airmap; @@ -25,6 +30,7 @@ AirMapAdvisory::AirMapAdvisory(QObject* parent) AirMapAdvisoryManager::AirMapAdvisoryManager(AirMapSharedState& shared, QObject *parent) : AirspaceAdvisoryProvider(parent) , _valid(false) + , _lastRadius(0.0) , _shared(shared) { } @@ -34,9 +40,10 @@ void AirMapAdvisoryManager::setROI(const QGeoCoordinate& center, double radiusMeters) { //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates. - if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > ADVISORY_UPDATE_DISTANCE) { + if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > ADVISORY_UPDATE_DISTANCE || _lastRadius != radiusMeters) { + _lastRadius = radiusMeters; _lastRoiCenter = center; - _requestAdvisories(center, radiusMeters); + _requestAdvisories(); } } @@ -52,7 +59,7 @@ adv_sort(QObject* a, QObject* b) //----------------------------------------------------------------------------- void -AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, double radiusMeters) +AirMapAdvisoryManager::_requestAdvisories() { qCDebug(AirMapManagerLog) << "Advisories Request"; if (!_shared.client()) { @@ -64,11 +71,14 @@ AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, doub _valid = false; _airspaces.clearAndDeleteContents(); Status::GetStatus::Parameters params; - params.longitude = coordinate.longitude(); - params.latitude = coordinate.latitude(); + params.longitude = _lastRoiCenter.longitude(); + params.latitude = _lastRoiCenter.latitude(); + params.types = Airspace::Type::all; params.weather = false; - params.buffer = radiusMeters; - _shared.client()->status().get_status_by_point(params, [this, coordinate](const Status::GetStatus::Result& result) { + params.buffer = _lastRadius; + std::weak_ptr isAlive(_instance); + _shared.client()->status().get_status_by_point(params, [this, isAlive](const Status::GetStatus::Result& result) { + if (!isAlive.lock()) return; if (result) { qCDebug(AirMapManagerLog) << "Successful advisory search. Items:" << result.value().advisories.size(); _airspaceColor = (AirspaceAdvisoryProvider::AdvisoryColor)(int)result.value().advisory_color; @@ -79,10 +89,6 @@ AirMapAdvisoryManager::_requestAdvisories(const QGeoCoordinate& coordinate, doub pAdvisory->_name = QString::fromStdString(advisory.airspace.name()); pAdvisory->_type = (AirspaceAdvisory::AdvisoryType)(int)advisory.airspace.type(); pAdvisory->_color = (AirspaceAdvisoryProvider::AdvisoryColor)(int)advisory.color; - //-- TODO: Add airspace center coordinates and radius (easy to get from Json but - // I have no idea how to get it from airmap::Airspace.) - // pAdvisory->_coordinates = QGeoCoordinate( something ); - // pAdvisory->_radius = something ; _airspaces.append(pAdvisory); qCDebug(AirMapManagerLog) << "Adding advisory" << pAdvisory->name(); } diff --git a/src/Airmap/AirMapAdvisoryManager.h b/src/Airmap/AirMapAdvisoryManager.h index b6f305010ab63067e2a7682fb5c43a4dd2e438d6..37af8400c34f24a2065f964fe228997259d369e8 100644 --- a/src/Airmap/AirMapAdvisoryManager.h +++ b/src/Airmap/AirMapAdvisoryManager.h @@ -60,9 +60,10 @@ public: signals: void error (const QString& what, const QString& airmapdMessage, const QString& airmapdDetails); private: - void _requestAdvisories (const QGeoCoordinate& coordinate, double radiusMeters); + void _requestAdvisories(); private: bool _valid; + double _lastRadius; AirMapSharedState& _shared; QGeoCoordinate _lastRoiCenter; QmlObjectListModel _airspaces; diff --git a/src/Airmap/AirMapManager.cc b/src/Airmap/AirMapManager.cc index 493cdd3476b0b0069b024861a072ee21d1b5a1e8..e432d651642c567a9940d0654149fdffecb95196 100644 --- a/src/Airmap/AirMapManager.cc +++ b/src/Airmap/AirMapManager.cc @@ -10,10 +10,10 @@ #include "AirMapManager.h" #include "AirMapAdvisoryManager.h" #include "AirMapWeatherInfoManager.h" -#include "AirMapRestrictionManager.h" #include "AirMapRulesetsManager.h" #include "AirMapSettings.h" #include "AirMapTelemetry.h" +#include "AirMapRestrictionManager.h" #include "AirMapTrafficMonitor.h" #include "AirMapVehicleManager.h" @@ -112,14 +112,6 @@ AirMapManager::instantiateVehicle(const Vehicle& vehicle) return manager; } -AirspaceRestrictionProvider* -AirMapManager::instantiateRestrictionProvider() -{ - AirMapRestrictionManager* restrictionManager = new AirMapRestrictionManager(_shared); - connect(restrictionManager, &AirMapRestrictionManager::error, this, &AirMapManager::_error); - return restrictionManager; -} - AirspaceRulesetsProvider* AirMapManager::instantiateRulesetsProvider() { @@ -143,3 +135,11 @@ AirMapManager::instatiateAirspaceAdvisoryProvider() connect(advisories, &AirMapAdvisoryManager::error, this, &AirMapManager::_error); return advisories; } + +AirspaceRestrictionProvider* +AirMapManager::instantiateAirspaceRestrictionProvider() +{ + AirMapRestrictionManager* airspaces = new AirMapRestrictionManager(_shared); + connect(airspaces, &AirMapRestrictionManager::error, this, &AirMapManager::_error); + return airspaces; +} diff --git a/src/Airmap/AirMapManager.h b/src/Airmap/AirMapManager.h index cea6af5de45ed83a11086d347462b71349dd220c..81d84e991790a61c9aa00dc437d64c9afba4bdbf 100644 --- a/src/Airmap/AirMapManager.h +++ b/src/Airmap/AirMapManager.h @@ -20,10 +20,10 @@ class QGCToolbox; class AirspaceVehicleManager; -class AirspaceRestrictionProvider; class AirspaceRulesetsProvider; class AirspaceWeatherInfoProvider; class AirspaceAdvisoryProvider; +class AirspaceRestrictionProvider; Q_DECLARE_LOGGING_CATEGORY(AirMapManagerLog) @@ -44,10 +44,10 @@ public: void setToolbox (QGCToolbox* toolbox) override; AirspaceVehicleManager* instantiateVehicle (const Vehicle& vehicle) override; - AirspaceRestrictionProvider* instantiateRestrictionProvider () override; AirspaceRulesetsProvider* instantiateRulesetsProvider () override; AirspaceWeatherInfoProvider* instatiateAirspaceWeatherInfoProvider () override; AirspaceAdvisoryProvider* instatiateAirspaceAdvisoryProvider () override; + AirspaceRestrictionProvider* instantiateAirspaceRestrictionProvider () override; QString name () const override { return "AirMap"; } diff --git a/src/Airmap/AirMapRestrictionManager.cc b/src/Airmap/AirMapRestrictionManager.cc index db6432b49fbdbd768e05a71e93977b028e158e20..777f61160dccb4adace79d43ec24932e2c0d6e2d 100644 --- a/src/Airmap/AirMapRestrictionManager.cc +++ b/src/Airmap/AirMapRestrictionManager.cc @@ -13,15 +13,32 @@ #include "airmap/airspaces.h" +#define RESTRICTION_UPDATE_DISTANCE 500 //-- 500m threshold for updates + using namespace airmap; +//----------------------------------------------------------------------------- AirMapRestrictionManager::AirMapRestrictionManager(AirMapSharedState& shared) : _shared(shared) + , _lastRadius(0.0) { } +//----------------------------------------------------------------------------- void AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMeters) +{ + //-- If first time or we've moved more than ADVISORY_UPDATE_DISTANCE, ask for updates. + if(!_lastRoiCenter.isValid() || _lastRoiCenter.distanceTo(center) > RESTRICTION_UPDATE_DISTANCE || _lastRadius != radiusMeters) { + _lastRadius = radiusMeters; + _lastRoiCenter = center; + _requestRestrictions(center, radiusMeters); + } +} + +//----------------------------------------------------------------------------- +void +AirMapRestrictionManager::_requestRestrictions(const QGeoCoordinate& center, double radiusMeters) { if (!_shared.client()) { qCDebug(AirMapManagerLog) << "No AirMap client instance. Not updating Airspace"; @@ -32,8 +49,8 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete return; } qCDebug(AirMapManagerLog) << "setting ROI"; - _polygonList.clear(); - _circleList.clear(); + _polygons.clear(); + _circles.clear(); _state = State::RetrieveItems; Airspaces::Search::Parameters params; params.geometry = Geometry::point(center.latitude(), center.longitude()); @@ -52,19 +69,19 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete switch(geometry.type()) { case Geometry::Type::polygon: { const Geometry::Polygon& polygon = geometry.details_for_polygon(); - _addPolygonToList(polygon, _polygonList); + _addPolygonToList(polygon); } break; case Geometry::Type::multi_polygon: { const Geometry::MultiPolygon& multiPolygon = geometry.details_for_multi_polygon(); for (const auto& polygon : multiPolygon) { - _addPolygonToList(polygon, _polygonList); + _addPolygonToList(polygon); } } break; case Geometry::Type::point: { const Geometry::Point& point = geometry.details_for_point(); - _circleList.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0.)); + _circles.append(new AirspaceCircularRestriction(QGeoCoordinate(point.latitude, point.longitude), 0.)); // TODO: radius??? } break; @@ -78,13 +95,13 @@ AirMapRestrictionManager::setROI(const QGeoCoordinate& center, double radiusMete emit error("Failed to retrieve Geofences", QString::fromStdString(result.error().message()), description); } - emit requestDone(true); _state = State::Idle; }); } +//----------------------------------------------------------------------------- void -AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon, QList& list) +AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& polygon) { QVariantList polygonArray; for (const auto& vertex : polygon.outer_ring.coordinates) { @@ -96,7 +113,7 @@ AirMapRestrictionManager::_addPolygonToList(const airmap::Geometry::Polygon& pol } polygonArray.append(QVariant::fromValue(coord)); } - list.append(new AirspacePolygonRestriction(polygonArray)); + _polygons.append(new AirspacePolygonRestriction(polygonArray)); if (polygon.inner_rings.size() > 0) { // no need to support those (they are rare, and in most cases, there's a more restrictive polygon filling the hole) qCDebug(AirMapManagerLog) << "Polygon with holes. Size: "<& list); + void _requestRestrictions(const QGeoCoordinate& center, double radiusMeters); + void _addPolygonToList (const airmap::Geometry::Polygon& polygon); + enum class State { Idle, RetrieveItems, }; - State _state = State::Idle; - AirMapSharedState& _shared; + + AirMapSharedState& _shared; + double _lastRadius; + QGeoCoordinate _lastRoiCenter; + State _state = State::Idle; + QmlObjectListModel _polygons; + QmlObjectListModel _circles; }; diff --git a/src/Airmap/AirMapRulesetsManager.cc b/src/Airmap/AirMapRulesetsManager.cc index 9277245779cee61a25cde56548d77a2021dd87ae..2906a84f2303b6e0b51eea65223f80f6608bb2eb 100644 --- a/src/Airmap/AirMapRulesetsManager.cc +++ b/src/Airmap/AirMapRulesetsManager.cc @@ -35,7 +35,7 @@ void AirMapRulesetsManager::setROI(const QGeoCoordinate& center) return; } if (_state != State::Idle) { - qCWarning(AirMapManagerLog) << "AirMapRestrictionManager::updateROI: state not idle"; + qCWarning(AirMapManagerLog) << "AirMapRulesetsManager::updateROI: state not idle"; return; } qCDebug(AirMapManagerLog) << "Setting ROI for Rulesets"; diff --git a/src/Airmap/README.md b/src/Airmap/README.md index a93d003c816c38e17572a85c7941efa3172f60aa..c3977d352fffc2940bf6e053b66d3a3f1b0150a7 100644 --- a/src/Airmap/README.md +++ b/src/Airmap/README.md @@ -1,5 +1,7 @@ ## To be deleted when development is complete +* "Required" rules must be pre-selectd and cannot be unselected by the user + * AirMapRestrictionManager seems to be incomplete (if not redundant). Shouldn't we use the array of AirSpace items returned by AirMapAdvisoryManager instead? In addition to the AirSpace object, it gives you a color to use in order of importance. * Traffic monitor timeout is now set to 2 minutes following instructions from Thomas Voß. diff --git a/src/AirspaceManagement/AirspaceController.cc b/src/AirspaceManagement/AirspaceController.cc index 91397ddc1ffaf7c8acf8b69bbdfb2197573ebb71..9bc18116fbfed782369d63d480a3da67d771b163 100644 --- a/src/AirspaceManagement/AirspaceController.cc +++ b/src/AirspaceManagement/AirspaceController.cc @@ -29,18 +29,6 @@ AirspaceController::setROI(QGeoCoordinate center, double radius) _manager->setROI(center, radius); } -QmlObjectListModel* -AirspaceController::polygons() -{ - return _manager->polygonRestrictions(); -} - -QmlObjectListModel* -AirspaceController::circles() -{ - return _manager->circularRestrictions(); -} - QString AirspaceController::providerName() { @@ -64,3 +52,9 @@ AirspaceController::rulesets() { return _manager->rulesets(); } + +AirspaceRestrictionProvider* +AirspaceController::airspaces() +{ + return _manager->airspaces(); +} diff --git a/src/AirspaceManagement/AirspaceController.h b/src/AirspaceManagement/AirspaceController.h index ef1b0f905ab3365833081b7e0ab3d9e6d2dbb7de..4b0ab7243f922acfc2a7ecce6b41710c46ee7155 100644 --- a/src/AirspaceManagement/AirspaceController.h +++ b/src/AirspaceManagement/AirspaceController.h @@ -17,6 +17,7 @@ class QmlObjectListModel; class AirspaceWeatherInfoProvider; class AirspaceAdvisoryProvider; class AirspaceRulesetsProvider; +class AirspaceRestrictionProvider; class AirspaceController : public QObject { @@ -25,22 +26,20 @@ public: AirspaceController(QObject* parent = NULL); ~AirspaceController() = default; - Q_PROPERTY(QmlObjectListModel* polygons READ polygons CONSTANT) ///< List of AirspacePolygonRestriction objects - Q_PROPERTY(QmlObjectListModel* circles READ circles CONSTANT) ///< List of AirspaceCircularRestriction objects Q_PROPERTY(QString providerName READ providerName CONSTANT) Q_PROPERTY(AirspaceWeatherInfoProvider* weatherInfo READ weatherInfo CONSTANT) Q_PROPERTY(AirspaceAdvisoryProvider* advisories READ advisories CONSTANT) Q_PROPERTY(AirspaceRulesetsProvider* rulesets READ rulesets CONSTANT) + Q_PROPERTY(AirspaceRestrictionProvider* airspaces READ airspaces CONSTANT) Q_PROPERTY(bool airspaceVisible READ airspaceVisible WRITE setairspaceVisible NOTIFY airspaceVisibleChanged) Q_INVOKABLE void setROI (QGeoCoordinate center, double radius); - QmlObjectListModel* polygons (); - QmlObjectListModel* circles (); QString providerName (); AirspaceWeatherInfoProvider* weatherInfo (); AirspaceAdvisoryProvider* advisories (); AirspaceRulesetsProvider* rulesets (); + AirspaceRestrictionProvider* airspaces (); bool airspaceVisible () { return _airspaceVisible; } void setairspaceVisible (bool set) { _airspaceVisible = set; emit airspaceVisibleChanged(); } diff --git a/src/AirspaceManagement/AirspaceManager.cc b/src/AirspaceManagement/AirspaceManager.cc index 1a94762e94c206c2966988c14bd11dd12919b415..4ca953306a81a963d2315a3c29451ce0e4a60e52 100644 --- a/src/AirspaceManagement/AirspaceManager.cc +++ b/src/AirspaceManagement/AirspaceManager.cc @@ -12,8 +12,8 @@ #include "AirspaceWeatherInfoProvider.h" #include "AirspaceAdvisoryProvider.h" #include "AirspaceRestriction.h" -#include "AirspaceRestrictionProvider.h" #include "AirspaceRulesetsProvider.h" +#include "AirspaceRestrictionProvider.h" #include "AirspaceVehicleManager.h" #include "AirspaceController.h" @@ -28,12 +28,13 @@ AirspaceManager::AirspaceManager(QGCApplication* app, QGCToolbox* toolbox) _roiUpdateTimer.setInterval(2000); _roiUpdateTimer.setSingleShot(true); connect(&_roiUpdateTimer, &QTimer::timeout, this, &AirspaceManager::_updateToROI); - qmlRegisterUncreatableType ("QGroundControl", 1, 0, "AirspaceAuthorization", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceController", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceWeatherInfoProvider","Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceAdvisoryProvider", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRule", "Reference only"); - qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRulesetsProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl", 1, 0, "AirspaceAuthorization", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceController", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceWeatherInfoProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceAdvisoryProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRule", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRulesetsProvider", "Reference only"); + qmlRegisterUncreatableType ("QGroundControl.Vehicle", 1, 0, "AirspaceRestrictionProvider", "Reference only"); } AirspaceManager::~AirspaceManager() @@ -47,24 +48,19 @@ AirspaceManager::~AirspaceManager() if(_rulesetsProvider) { delete _rulesetsProvider; } - if (_restrictionsProvider) { - delete _restrictionsProvider; + if(_airspaces) { + delete _airspaces; } - _polygonRestrictions.clearAndDeleteContents(); - _circleRestrictions.clearAndDeleteContents(); } void AirspaceManager::setToolbox(QGCToolbox* toolbox) { QGCTool::setToolbox(toolbox); // We should not call virtual methods in the constructor, so we instantiate the restriction provider here - _restrictionsProvider = instantiateRestrictionProvider(); - if (_restrictionsProvider) { - connect(_restrictionsProvider, &AirspaceRestrictionProvider::requestDone, this, &AirspaceManager::_restrictionsUpdated); - } _rulesetsProvider = instantiateRulesetsProvider(); _weatherProvider = instatiateAirspaceWeatherInfoProvider(); _advisories = instatiateAirspaceAdvisoryProvider(); + _airspaces = instantiateAirspaceRestrictionProvider(); } void AirspaceManager::setROI(const QGeoCoordinate& center, double radiusMeters) @@ -76,8 +72,8 @@ void AirspaceManager::setROI(const QGeoCoordinate& center, double radiusMeters) void AirspaceManager::_updateToROI() { - if (_restrictionsProvider) { - _restrictionsProvider->setROI(_roiCenter, _roiRadius); + if(_airspaces) { + _airspaces->setROI(_roiCenter, _roiRadius); } if(_rulesetsProvider) { _rulesetsProvider->setROI(_roiCenter); @@ -89,24 +85,3 @@ void AirspaceManager::_updateToROI() _advisories->setROI(_roiCenter, _roiRadius); } } - -void AirspaceManager::_restrictionsUpdated(bool success) -{ - _polygonRestrictions.clearAndDeleteContents(); - _circleRestrictions.clearAndDeleteContents(); - if (success) { - for (const auto& circle : _restrictionsProvider->circles()) { - _circleRestrictions.append(circle); - } - for (const auto& polygon : _restrictionsProvider->polygons()) { - _polygonRestrictions.append(polygon); - } - } else { - // TODO: show error? - } -} - -void AirspaceManager::_rulessetsUpdated(bool) -{ - -} diff --git a/src/AirspaceManagement/AirspaceManager.h b/src/AirspaceManagement/AirspaceManager.h index 349298402773332ca41addd10adef35e73d189e5..93e7f3e625c18894688dd4523b16f9488c4b82bc 100644 --- a/src/AirspaceManagement/AirspaceManager.h +++ b/src/AirspaceManagement/AirspaceManager.h @@ -18,8 +18,8 @@ * classes. * - AirspaceVehicleManager * this provides the multi-vehicle support - each vehicle has an instance - * - AirspaceRestrictionProvider - * provides airspace restrictions. Currently only used by AirspaceManager, but + * - AirspaceAdvisoriesProvider + * Provides airspace advisories and restrictions. Currently only used by AirspaceManager, but * each vehicle could have its own restrictions. */ @@ -36,10 +36,10 @@ class Vehicle; class QGCApplication; class AirspaceWeatherInfoProvider; -class AirspaceRestrictionProvider; class AirspaceRulesetsProvider; class AirspaceVehicleManager; class AirspaceAdvisoryProvider; +class AirspaceRestrictionProvider; Q_DECLARE_LOGGING_CATEGORY(AirspaceManagementLog) @@ -59,11 +59,6 @@ public: */ virtual AirspaceVehicleManager* instantiateVehicle (const Vehicle& vehicle) = 0; - /** - * Factory method to create an AirspaceRestrictionProvider object - */ - virtual AirspaceRestrictionProvider* instantiateRestrictionProvider () = 0; - /** * Factory method to create an AirspaceRulesetsProvider object */ @@ -79,6 +74,11 @@ public: */ virtual AirspaceAdvisoryProvider* instatiateAirspaceAdvisoryProvider () = 0; + /** + * Factory method to create an AirspaceRestrictionProvider object + */ + virtual AirspaceRestrictionProvider* instantiateAirspaceRestrictionProvider () = 0; + /** * Set the ROI for airspace information (restrictions shown in UI) * @param center Center coordinate for ROI @@ -86,11 +86,10 @@ public: */ void setROI (const QGeoCoordinate& center, double radiusMeters); - QmlObjectListModel* polygonRestrictions () { return &_polygonRestrictions; } - QmlObjectListModel* circularRestrictions () { return &_circleRestrictions; } AirspaceWeatherInfoProvider* weatherInfo () { return _weatherProvider; } AirspaceAdvisoryProvider* advisories () { return _advisories; } AirspaceRulesetsProvider* rulesets () { return _rulesetsProvider; } + AirspaceRestrictionProvider* airspaces () { return _airspaces; } void setToolbox(QGCToolbox* toolbox) override; @@ -99,22 +98,13 @@ public: */ virtual QString name () const = 0; -protected slots: - virtual void _rulessetsUpdated (bool success); - -private slots: - void _restrictionsUpdated (bool success); - private: void _updateToROI (); - AirspaceRestrictionProvider* _restrictionsProvider = nullptr; ///< Restrictions that are shown in the UI - AirspaceRulesetsProvider* _rulesetsProvider = nullptr; ///< Restrictions that are shown in the UI + AirspaceRulesetsProvider* _rulesetsProvider = nullptr; ///< Rulesets that are shown in the UI AirspaceWeatherInfoProvider* _weatherProvider = nullptr; ///< Weather info that is shown in the UI AirspaceAdvisoryProvider* _advisories = nullptr; ///< Advisory info that is shown in the UI - - QmlObjectListModel _polygonRestrictions; ///< current polygon restrictions - QmlObjectListModel _circleRestrictions; ///< current circle restrictions + AirspaceRestrictionProvider* _airspaces = nullptr; ///< Airspace info that is shown in the UI QTimer _roiUpdateTimer; QGeoCoordinate _roiCenter; diff --git a/src/AirspaceManagement/AirspaceRestrictionProvider.h b/src/AirspaceManagement/AirspaceRestrictionProvider.h index 6e1c0828e9813ac92e62f6326b56316c6334a946..2b627ec8e47d1e70689c09c03ec4e76898c36f98 100644 --- a/src/AirspaceManagement/AirspaceRestrictionProvider.h +++ b/src/AirspaceManagement/AirspaceRestrictionProvider.h @@ -14,6 +14,8 @@ * Base class that queries for airspace restrictions */ +#include "QmlObjectListModel.h" + #include #include #include @@ -27,6 +29,9 @@ public: AirspaceRestrictionProvider (QObject* parent = NULL); ~AirspaceRestrictionProvider () = default; + Q_PROPERTY(QmlObjectListModel* polygons READ polygons CONSTANT) + Q_PROPERTY(QmlObjectListModel* circles READ circles CONSTANT) + /** * Set region of interest that should be queried. When finished, the requestDone() signal will be emmited. * @param center Center coordinate for ROI @@ -34,13 +39,6 @@ public: */ virtual void setROI (const QGeoCoordinate& center, double radiusMeters) = 0; - const QList& polygons() const { return _polygonList; } - const QList& circles () const { return _circleList; } - -signals: - void requestDone (bool success); - -protected: - QList _polygonList; - QList _circleList; + virtual QmlObjectListModel* polygons () = 0; ///< List of AirspacePolygonRestriction objects + virtual QmlObjectListModel* circles () = 0; ///< List of AirspaceCircularRestriction objects }; diff --git a/src/FlightDisplay/FlightDisplayViewMap.qml b/src/FlightDisplay/FlightDisplayViewMap.qml index ca85172637f3199c3cbaedbf6e6e5e540a6fbee9..00acc809b19304c961418b821d222c007e7da385 100644 --- a/src/FlightDisplay/FlightDisplayViewMap.qml +++ b/src/FlightDisplay/FlightDisplayViewMap.qml @@ -331,21 +331,21 @@ FlightMap { // Airspace overlap support MapItemView { - model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.circles : [] + model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.airspaces.circles : [] delegate: MapCircle { center: object.center radius: object.radius + color: Qt.rgba(0.94, 0.87, 0, 0.15) border.color: Qt.rgba(1,1,1,0.85) - color: Qt.rgba(0.94,0.87,0,0.25) } } MapItemView { - model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.polygons : [] + model: _airspaceManagement && _activeVehicle.airspaceController.airspaceVisible ? _activeVehicle.airspaceController.airspaces.polygons : [] delegate: MapPolygon { - border.color: Qt.rgba(1,1,1,0.85) - color: Qt.rgba(0.94,0.87,0,0.25) path: object.polygon + color: Qt.rgba(0.94, 0.87, 0, 0.15) + border.color: Qt.rgba(1,1,1,0.85) } } }