Plan supports transition from offline<->online without losing data

src/MissionManager/GeoFenceController.cc

@@ -34,13 +34,16 @@ QGC_LOGGING_CATEGORY(GeoFenceControllerLog, "GeoFenceControllerLog")
 const char* GeoFenceController::_jsonFileTypeValue =    "GeoFence";
 const char* GeoFenceController::_jsonBreachReturnKey =  "breachReturn";
 
-GeoFenceController::GeoFenceController(QObject* parent)
-    : PlanElementController(parent)
+GeoFenceController::GeoFenceController(PlanMasterController* masterController, QObject* parent)
+    : PlanElementController(masterController, parent)
+    , _geoFenceManager(_managerVehicle->geoFenceManager())
     , _dirty(false)
     , _mapPolygon(this)
 {
     connect(_mapPolygon.qmlPathModel(), &QmlObjectListModel::countChanged, this, &GeoFenceController::_updateContainsItems);
     connect(_mapPolygon.qmlPathModel(), &QmlObjectListModel::dirtyChanged, this, &GeoFenceController::_polygonDirtyChanged);
+
+    managerVehicleChanged(_managerVehicle);
 }
 
 GeoFenceController::~GeoFenceController()
@@ -56,14 +59,6 @@ void GeoFenceController::start(bool editMode)
     _init();
 }
 
-void GeoFenceController::startStaticActiveVehicle(Vehicle* vehicle)
-{
-    qCDebug(GeoFenceControllerLog) << "startStaticActiveVehicle";
-
-    PlanElementController::startStaticActiveVehicle(vehicle);
-    _init();
-}
-
 void GeoFenceController::_init(void)
 {
 
@@ -89,26 +84,31 @@ void GeoFenceController::_signalAll(void)
     emit dirtyChanged(dirty());
 }
 
-void GeoFenceController::activeVehicleBeingRemoved(void)
+void GeoFenceController::managerVehicleChanged(Vehicle* managerVehicle)
 {
-    _activeVehicle->geoFenceManager()->disconnect(this);
-    _activeVehicle = NULL;
-}
+    if (_managerVehicle) {
+        _geoFenceManager->disconnect(this);
+        _managerVehicle = NULL;
+        _geoFenceManager = NULL;
+    }
 
-void GeoFenceController::activeVehicleSet(Vehicle* vehicle)
-{
-    _activeVehicle = vehicle;
-    GeoFenceManager* geoFenceManager = _activeVehicle->geoFenceManager();
-    connect(geoFenceManager, &GeoFenceManager::breachReturnSupportedChanged,    this, &GeoFenceController::breachReturnSupportedChanged);
-    connect(geoFenceManager, &GeoFenceManager::circleEnabledChanged,            this, &GeoFenceController::circleEnabledChanged);
-    connect(geoFenceManager, &GeoFenceManager::circleRadiusFactChanged,         this, &GeoFenceController::circleRadiusFactChanged);
-    connect(geoFenceManager, &GeoFenceManager::polygonEnabledChanged,           this, &GeoFenceController::polygonEnabledChanged);
-    connect(geoFenceManager, &GeoFenceManager::polygonSupportedChanged,         this, &GeoFenceController::polygonSupportedChanged);
-    connect(geoFenceManager, &GeoFenceManager::loadComplete,                    this, &GeoFenceController::_loadComplete);
-    connect(geoFenceManager, &GeoFenceManager::inProgressChanged,               this, &GeoFenceController::syncInProgressChanged);
-
-    if (!geoFenceManager->inProgress()) {
-        _loadComplete(geoFenceManager->breachReturnPoint(), geoFenceManager->polygon());
+    _managerVehicle = managerVehicle;
+    if (!_managerVehicle) {
+        qWarning() << "GeoFenceController::managerVehicleChanged managerVehicle=NULL";
+        return;
+    }
+
+    _geoFenceManager = _managerVehicle->geoFenceManager();
+    connect(_geoFenceManager, &GeoFenceManager::breachReturnSupportedChanged,   this, &GeoFenceController::breachReturnSupportedChanged);
+    connect(_geoFenceManager, &GeoFenceManager::circleEnabledChanged,           this, &GeoFenceController::circleEnabledChanged);
+    connect(_geoFenceManager, &GeoFenceManager::circleRadiusFactChanged,        this, &GeoFenceController::circleRadiusFactChanged);
+    connect(_geoFenceManager, &GeoFenceManager::polygonEnabledChanged,          this, &GeoFenceController::polygonEnabledChanged);
+    connect(_geoFenceManager, &GeoFenceManager::polygonSupportedChanged,        this, &GeoFenceController::polygonSupportedChanged);
+    connect(_geoFenceManager, &GeoFenceManager::loadComplete,                   this, &GeoFenceController::_loadComplete);
+    connect(_geoFenceManager, &GeoFenceManager::inProgressChanged,              this, &GeoFenceController::syncInProgressChanged);
+
+    if (!_geoFenceManager->inProgress()) {
+        _loadComplete(_geoFenceManager->breachReturnPoint(), _geoFenceManager->polygon());
     }
 
     _signalAll();
@@ -158,27 +158,23 @@ void GeoFenceController::removeAll(void)
 
 void GeoFenceController::loadFromVehicle(void)
 {
-    if (_activeVehicle->parameterManager()->parametersReady() && !syncInProgress()) {
-        _activeVehicle->geoFenceManager()->loadFromVehicle();
+    if (!syncInProgress()) {
+        _geoFenceManager->loadFromVehicle();
     } else {
-        qCWarning(GeoFenceControllerLog) << "GeoFenceController::loadFromVehicle call at wrong time" << _activeVehicle->parameterManager()->parametersReady() << syncInProgress();
+        qCWarning(GeoFenceControllerLog) << "GeoFenceController::loadFromVehicle call while syncInProgress";
     }
 }
 
 void GeoFenceController::sendToVehicle(void)
 {
-    if (_activeVehicle->parameterManager()->parametersReady() && !syncInProgress()) {
-        _activeVehicle->geoFenceManager()->sendToVehicle(_breachReturnPoint, _mapPolygon.pathModel());
-        _mapPolygon.setDirty(false);
-        setDirty(false);
-    } else {
-        qCWarning(GeoFenceControllerLog) << "GeoFenceController::loadFromVehicle call at wrong time" << _activeVehicle->parameterManager()->parametersReady() << syncInProgress();
-    }
+    _geoFenceManager->sendToVehicle(_breachReturnPoint, _mapPolygon.pathModel());
+    _mapPolygon.setDirty(false);
+    setDirty(false);
 }
 
 bool GeoFenceController::syncInProgress(void) const
 {
-    return _activeVehicle->geoFenceManager()->inProgress();
+    return _geoFenceManager->inProgress();
 }
 
 bool GeoFenceController::dirty(void) const
@@ -207,37 +203,37 @@ void GeoFenceController::_polygonDirtyChanged(bool dirty)
 
 bool GeoFenceController::breachReturnSupported(void) const
 {
-    return _activeVehicle->geoFenceManager()->breachReturnSupported();
+    return _geoFenceManager->breachReturnSupported();
 }
 
 bool GeoFenceController::circleEnabled(void) const
 {
-    return _activeVehicle->geoFenceManager()->circleEnabled();
+    return _geoFenceManager->circleEnabled();
 }
 
 Fact* GeoFenceController::circleRadiusFact(void) const
 {
-    return _activeVehicle->geoFenceManager()->circleRadiusFact();
+    return _geoFenceManager->circleRadiusFact();
 }
 
 bool GeoFenceController::polygonSupported(void) const
 {
-    return _activeVehicle->geoFenceManager()->polygonSupported();
+    return _geoFenceManager->polygonSupported();
 }
 
 bool GeoFenceController::polygonEnabled(void) const
 {
-    return _activeVehicle->geoFenceManager()->polygonEnabled();
+    return _geoFenceManager->polygonEnabled();
 }
 
 QVariantList GeoFenceController::params(void) const
 {
-    return _activeVehicle->geoFenceManager()->params();
+    return _geoFenceManager->params();
 }
 
 QStringList GeoFenceController::paramLabels(void) const
 {
-    return _activeVehicle->geoFenceManager()->paramLabels();
+    return _geoFenceManager->paramLabels();
 }
 
 void GeoFenceController::_setDirty(void)
@@ -280,5 +276,5 @@ void GeoFenceController::_updateContainsItems(void)
 
 void GeoFenceController::removeAllFromVehicle(void)
 {
-    _activeVehicle->geoFenceManager()->removeAll();
+    _geoFenceManager->removeAll();
 }

src/MissionManager/GeoFenceController.h

@@ -26,7 +26,7 @@ class GeoFenceController : public PlanElementController
     Q_OBJECT
     
 public:
-    GeoFenceController(QObject* parent = NULL);
+    GeoFenceController(PlanMasterController* masterController, QObject* parent = NULL);
     ~GeoFenceController();
 
     Q_PROPERTY(QGCMapPolygon*   mapPolygon              READ mapPolygon                                         CONSTANT)
@@ -45,7 +45,6 @@ public:
     Q_INVOKABLE void removePolygon  (void) { _mapPolygon.clear(); }
 
     void start                      (bool editMode) final;
-    void startStaticActiveVehicle   (Vehicle* vehicle) final;
     void save                       (QJsonObject& json) final;
     bool load                       (const QJsonObject& json, QString& errorString) final;
     void loadFromVehicle            (void) final;
@@ -56,8 +55,7 @@ public:
     bool dirty                      (void) const final;
     void setDirty                   (bool dirty) final;
     bool containsItems              (void) const final;
-    void activeVehicleBeingRemoved  (void) final;
-    void activeVehicleSet           (Vehicle* vehicle) final;
+    void managerVehicleChanged      (Vehicle* managerVehicle) final;
 
     bool            circleEnabled           (void) const;
     Fact*           circleRadiusFact        (void) const;
@@ -96,9 +94,10 @@ private:
     void _init(void);
     void _signalAll(void);
 
-    bool            _dirty;
-    QGCMapPolygon   _mapPolygon;
-    QGeoCoordinate  _breachReturnPoint;
+    GeoFenceManager*    _geoFenceManager;
+    bool                _dirty;
+    QGCMapPolygon       _mapPolygon;
+    QGeoCoordinate      _breachReturnPoint;
 
     static const char* _jsonFileTypeValue;
     static const char* _jsonBreachReturnKey;

src/MissionManager/MissionController.h

@@ -24,17 +24,19 @@ class VisualMissionItem;
 class MissionItem;
 class MissionSettingsItem;
 class AppSettings;
+class MissionManager;
 
 Q_DECLARE_LOGGING_CATEGORY(MissionControllerLog)
 
 typedef QPair<VisualMissionItem*,VisualMissionItem*> VisualItemPair;
 typedef QHash<VisualItemPair, CoordinateVector*> CoordVectHashTable;
+
 class MissionController : public PlanElementController
 {
     Q_OBJECT
 
 public:
-    MissionController(QObject* parent = NULL);
+    MissionController(PlanMasterController* masterController, QObject* parent = NULL);
     ~MissionController();
 
     typedef struct {
@@ -110,7 +112,6 @@ public:
 
     // Overrides from PlanElementController
     void start                      (bool editMode) final;
-    void startStaticActiveVehicle   (Vehicle* vehicle) final;
     void save                       (QJsonObject& json) final;
     bool load                       (const QJsonObject& json, QString& errorString) final;
     void loadFromVehicle            (void) final;
@@ -121,8 +122,7 @@ public:
     bool dirty                      (void) const final;
     void setDirty                   (bool dirty) final;
     bool containsItems              (void) const final;
-    void activeVehicleBeingRemoved  (void) final;
-    void activeVehicleSet           (Vehicle* vehicle) final;
+    void managerVehicleChanged      (Vehicle* managerVehicle) final;
 
     // Property accessors
 
@@ -169,7 +169,7 @@ signals:
 private slots:
     void _newMissionItemsAvailableFromVehicle(bool removeAllRequested);
     void _itemCommandChanged(void);
-    void _activeVehicleHomePositionChanged(const QGeoCoordinate& homePosition);
+    void _managerVehicleHomePositionChanged(const QGeoCoordinate& homePosition);
     void _inProgressChanged(bool inProgress);
     void _currentMissionIndexChanged(int sequenceNumber);
     void _recalcWaypointLines(void);
@@ -177,6 +177,7 @@ private slots:
     void _updateContainsItems(void);
     void _cameraFeedback(QGeoCoordinate imageCoordinate, int index);
     void _progressPctChanged(double progressPct);
+    void _visualItemsDirtyChanged(bool dirty);
 
 private:
     void _init(void);
@@ -194,10 +195,10 @@ private:
     static double _normalizeLat(double lat);
     static double _normalizeLon(double lon);
     static void _addMissionSettings(Vehicle* vehicle, QmlObjectListModel* visualItems, bool addToCenter);
-    static bool _loadJsonMissionFile(Vehicle* vehicle, const QByteArray& bytes, QmlObjectListModel* visualItems, QString& errorString);
-    static bool _loadJsonMissionFileV1(Vehicle* vehicle, const QJsonObject& json, QmlObjectListModel* visualItems, QString& errorString);
-    static bool _loadJsonMissionFileV2(Vehicle* vehicle, const QJsonObject& json, QmlObjectListModel* visualItems, QString& errorString);
-    static bool _loadTextMissionFile(Vehicle* vehicle, QTextStream& stream, QmlObjectListModel* visualItems, QString& errorString);
+    bool _loadJsonMissionFile(const QByteArray& bytes, QmlObjectListModel* visualItems, QString& errorString);
+    bool _loadJsonMissionFileV1(const QJsonObject& json, QmlObjectListModel* visualItems, QString& errorString);
+    bool _loadJsonMissionFileV2(const QJsonObject& json, QmlObjectListModel* visualItems, QString& errorString);
+    bool _loadTextMissionFile(QTextStream& stream, QmlObjectListModel* visualItems, QString& errorString);
     int _nextSequenceNumber(void);
     static void _scanForAdditionalSettings(QmlObjectListModel* visualItems, Vehicle* vehicle);
     static bool _convertToMissionItems(QmlObjectListModel* visualMissionItems, QList<MissionItem*>& rgMissionItems, QObject* missionItemParent);
@@ -210,6 +211,7 @@ private:
     void _initLoadedVisualItems(QmlObjectListModel* loadedVisualItems);
 
 private:
+    MissionManager*         _missionManager;
     QmlObjectListModel*     _visualItems;
     MissionSettingsItem*    _settingsItem;
     QmlObjectListModel      _waypointLines;

src/MissionManager/MissionControllerTest.cc

@@ -13,6 +13,9 @@
 #include "MultiVehicleManager.h"
 #include "SimpleMissionItem.h"
 #include "MissionSettingsItem.h"
+#include "QGCApplication.h"
+#include "SettingsManager.h"
+#include "AppSettings.h"
 
 MissionControllerTest::MissionControllerTest(void)
     : _multiSpyMissionController(NULL)
@@ -24,8 +27,8 @@ MissionControllerTest::MissionControllerTest(void)
 
 void MissionControllerTest::cleanup(void)
 {
-    delete _missionController;
-    _missionController = NULL;
+    delete _masterController;
+    _masterController = NULL;
 
     delete _multiSpyMissionController;
     _multiSpyMissionController = NULL;
@@ -38,8 +41,6 @@ void MissionControllerTest::cleanup(void)
 
 void MissionControllerTest::_initForFirmwareType(MAV_AUTOPILOT firmwareType)
 {
-    bool startController = false;
-
     MissionControllerManagerTest::_initForFirmwareType(firmwareType);
 
     // VisualMissionItem signals
@@ -49,19 +50,16 @@ void MissionControllerTest::_initForFirmwareType(MAV_AUTOPILOT firmwareType)
     _rgMissionControllerSignals[visualItemsChangedSignalIndex] =    SIGNAL(visualItemsChanged());
     _rgMissionControllerSignals[waypointLinesChangedSignalIndex] =  SIGNAL(waypointLinesChanged());
 
-    if (!_missionController) {
-        startController = true;
-        _missionController = new MissionController();
-        Q_CHECK_PTR(_missionController);
-    }
+    // Master controller pulls offline vehicle info from settings
+    qgcApp()->toolbox()->settingsManager()->appSettings()->offlineEditingFirmwareType()->setRawValue(firmwareType);
+    _masterController = new PlanMasterController(this);
+    _missionController = _masterController->missionController();
 
     _multiSpyMissionController = new MultiSignalSpy();
     Q_CHECK_PTR(_multiSpyMissionController);
     QCOMPARE(_multiSpyMissionController->init(_missionController, _rgMissionControllerSignals, _cMissionControllerSignals), true);
 
-    if (startController) {
-        _missionController->start(true /* editMode */);
-    }
+    _masterController->start(true /* editMode */);
 
     // All signals should some through on start
     QCOMPARE(_multiSpyMissionController->checkOnlySignalsByMask(visualItemsChangedSignalMask | waypointLinesChangedSignalMask), true);
@@ -162,6 +160,7 @@ void MissionControllerTest::_testAddWayppointPX4(void)
     _testAddWaypointWorker(MAV_AUTOPILOT_PX4);
 }
 
+#if 0
 void MissionControllerTest::_testOfflineToOnlineWorker(MAV_AUTOPILOT firmwareType)
 {
     // Start offline and add item
@@ -191,6 +190,7 @@ void MissionControllerTest::_testOfflineToOnlinePX4(void)
 {
     _testOfflineToOnlineWorker(MAV_AUTOPILOT_PX4);
 }
+#endif
 
 void MissionControllerTest::_setupVisualItemSignals(VisualMissionItem* visualItem)
 {

src/MissionManager/MissionControllerTest.h

@@ -16,6 +16,7 @@
 #include "MissionManager.h"
 #include "MultiSignalSpy.h"
 #include "MissionControllerManagerTest.h"
+#include "PlanMasterController.h"
 #include "MissionController.h"
 #include "SimpleMissionItem.h"
 
@@ -38,14 +39,18 @@ private:
     void _testEmptyVehiclePX4(void);
     void _testAddWayppointAPM(void);
     void _testAddWayppointPX4(void);
+#if 0
     void _testOfflineToOnlineAPM(void);
     void _testOfflineToOnlinePX4(void);
+#endif
 
 private:
     void _initForFirmwareType(MAV_AUTOPILOT firmwareType);
     void _testEmptyVehicleWorker(MAV_AUTOPILOT firmwareType);
     void _testAddWaypointWorker(MAV_AUTOPILOT firmwareType);
+#if 0
     void _testOfflineToOnlineWorker(MAV_AUTOPILOT firmwareType);
+#endif
     void _setupVisualItemSignals(VisualMissionItem* visualItem);
 
     // MissiomItems signals
@@ -81,7 +86,8 @@ private:
     static const size_t _cVisualItemSignals = visualItemMaxSignalIndex;
     const char*         _rgVisualItemSignals[_cVisualItemSignals];
 
-    MissionController*  _missionController;
+    PlanMasterController*   _masterController;
+    MissionController*      _missionController;
 };
 
 #endif

src/MissionManager/PlanElementController.cc

@@ -8,13 +8,17 @@
  ****************************************************************************/
 
 #include "PlanElementController.h"
+#include "PlanMasterController.h"
 #include "QGCApplication.h"
 #include "MultiVehicleManager.h"
+#include "SettingsManager.h"
+#include "AppSettings.h"
 
-PlanElementController::PlanElementController(QObject* parent)
+PlanElementController::PlanElementController(PlanMasterController* masterController, QObject* parent)
     : QObject(parent)
-    , _multiVehicleMgr(qgcApp()->toolbox()->multiVehicleManager())
-    , _activeVehicle(_multiVehicleMgr->offlineEditingVehicle())
+    , _masterController(masterController)
+    , _controllerVehicle(masterController->controllerVehicle())
+    , _managerVehicle(masterController->managerVehicle())
     , _editMode(false)
 {
 
@@ -29,9 +33,3 @@ void PlanElementController::start(bool editMode)
 {
     _editMode = editMode;
 }
-
-void PlanElementController::startStaticActiveVehicle(Vehicle* vehicle)
-{
-    Q_UNUSED(vehicle);
-    _editMode = false;
-}

src/MissionManager/PlanElementController.h

@@ -15,6 +15,8 @@
 #include "Vehicle.h"
 #include "MultiVehicleManager.h"
 
+class PlanMasterController;
+
 /// This is the abstract base clas for Plan Element controllers.
 /// Examples of plan elements are: missions (MissionController), geofence (GeoFenceController)
 class PlanElementController : public QObject
@@ -22,21 +24,17 @@ class PlanElementController : public QObject
     Q_OBJECT
     
 public:
-    PlanElementController(QObject* parent = NULL);
+    PlanElementController(PlanMasterController* masterController, QObject* parent = NULL);
     ~PlanElementController();
     
-    Q_PROPERTY(bool         containsItems   READ containsItems                  NOTIFY containsItemsChanged)    ///< true: Elemement is non-empty
-    Q_PROPERTY(bool         syncInProgress  READ syncInProgress                 NOTIFY syncInProgressChanged)   ///< true: information is currently being saved/sent, false: no active save/send in progress
-    Q_PROPERTY(bool         dirty           READ dirty          WRITE setDirty  NOTIFY dirtyChanged)            ///< true: unsaved/sent changes are present, false: no changes since last save/send
-    Q_PROPERTY(Vehicle*     vehicle         READ vehicle                        NOTIFY vehicleChanged)
+    Q_PROPERTY(bool containsItems   READ containsItems                  NOTIFY containsItemsChanged)    ///< true: Elemement is non-empty
+    Q_PROPERTY(bool syncInProgress  READ syncInProgress                 NOTIFY syncInProgressChanged)   ///< true: information is currently being saved/sent, false: no active save/send in progress
+    Q_PROPERTY(bool dirty           READ dirty          WRITE setDirty  NOTIFY dirtyChanged)            ///< true: unsaved/sent changes are present, false: no changes since last save/send
 
     /// Should be called immediately upon Component.onCompleted.
     ///     @param editMode true: controller being used in Plan view, false: controller being used in Fly view
     virtual void start(bool editMode);
 
-    /// Starts the controller using a single static active vehicle. Will not track global active vehicle changes.
-    virtual void startStaticActiveVehicle(Vehicle* vehicle);
-
     virtual void save(QJsonObject& json) = 0;
     virtual bool load(const QJsonObject& json, QString& errorString) = 0;
     virtual void loadFromVehicle(void) = 0;
@@ -49,13 +47,8 @@ public:
     virtual bool    dirty          (void) const = 0;
     virtual void    setDirty       (bool dirty) = 0;
 
-    /// Called when the current active vehicle is about to be removed. Derived classes should override to implement custom behavior.
-    virtual void activeVehicleBeingRemoved(void) = 0;
-
-    /// Called when a new active vehicle has been set. Derived classes should override to implement custom behavior.
-    virtual void activeVehicleSet(Vehicle* activeVehicle) = 0;
-
-    Vehicle* vehicle(void) { return _activeVehicle; }
+    /// Called when a new manager vehicle has been set. Derived classes should override to implement custom behavior.
+    virtual void managerVehicleChanged(Vehicle* managerVehicle) = 0;
 
 signals:
     void containsItemsChanged   (bool containsItems);
@@ -64,8 +57,9 @@ signals:
     void vehicleChanged         (Vehicle* vehicle);
 
 protected:
-    MultiVehicleManager*    _multiVehicleMgr;
-    Vehicle*                _activeVehicle;     ///< Currently active vehicle, can be disconnected offline editing vehicle
+    PlanMasterController*   _masterController;
+    Vehicle*                _controllerVehicle;
+    Vehicle*                _managerVehicle;
     bool                    _editMode;
 };
 

src/MissionManager/PlanMasterController.cc

@@ -10,6 +10,7 @@
 #include "PlanMasterController.h"
 #include "QGCApplication.h"
 #include "MultiVehicleManager.h"
+#include "SettingsManager.h"
 #include "AppSettings.h"
 #include "JsonHelper.h"
 
@@ -25,8 +26,13 @@ const char* PlanMasterController::_jsonRallyPointsObjectKey =   "rallyPoints";
 PlanMasterController::PlanMasterController(QObject* parent)
     : QObject(parent)
     , _multiVehicleMgr(qgcApp()->toolbox()->multiVehicleManager())
-    , _activeVehicle(_multiVehicleMgr->offlineEditingVehicle())
+    , _controllerVehicle(new Vehicle((MAV_AUTOPILOT)qgcApp()->toolbox()->settingsManager()->appSettings()->offlineEditingFirmwareType()->rawValue().toInt(), (MAV_TYPE)qgcApp()->toolbox()->settingsManager()->appSettings()->offlineEditingVehicleType()->rawValue().toInt(), qgcApp()->toolbox()->firmwarePluginManager()))
+    , _managerVehicle(_controllerVehicle)
     , _editMode(false)
+    , _offline(true)
+    , _missionController(this)
+    , _geoFenceController(this)
+    , _rallyPointController(this)
 {
     connect(&_missionController,    &MissionController::dirtyChanged,       this, &PlanMasterController::dirtyChanged);
     connect(&_geoFenceController,   &GeoFenceController::dirtyChanged,      this, &PlanMasterController::dirtyChanged);
@@ -60,34 +66,42 @@ void PlanMasterController::start(bool editMode)
 void PlanMasterController::startStaticActiveVehicle(Vehicle* vehicle)
 {
     _editMode = false;
-    _missionController.startStaticActiveVehicle(vehicle);
-    _geoFenceController.startStaticActiveVehicle(vehicle);
-    _rallyPointController.startStaticActiveVehicle(vehicle);
     _activeVehicleChanged(vehicle);
 }
 
 void PlanMasterController::_activeVehicleChanged(Vehicle* activeVehicle)
 {
-    if (_activeVehicle) {
-        _missionController.activeVehicleBeingRemoved();
-        _geoFenceController.activeVehicleBeingRemoved();
-        _rallyPointController.activeVehicleBeingRemoved();
-        _activeVehicle = NULL;
+    if (_managerVehicle == activeVehicle) {
+        // We are already setup for this vehicle
+        return;
     }
 
-    if (activeVehicle) {
-        _activeVehicle = activeVehicle;
+    bool newOffline = false;
+    if (activeVehicle == NULL) {
+        // Since there is no longer an active vehicle we use the offline controller vehicle as the manager vehicle
+        _managerVehicle = _controllerVehicle;
+        newOffline = true;
     } else {
-        _activeVehicle = _multiVehicleMgr->offlineEditingVehicle();
+        // FIXME: Check for vehicle compatibility. (edit mode only)
+        _managerVehicle = activeVehicle;
+        newOffline = false;
+    }
+    if (newOffline != _offline) {
+        _offline = newOffline;
+        emit offlineEditingChanged(newOffline);
     }
-    _missionController.activeVehicleSet(_activeVehicle);
-    _geoFenceController.activeVehicleSet(_activeVehicle);
-    _rallyPointController.activeVehicleSet(_activeVehicle);
 
-    // Whenever vehicle changes we need to update syncInProgress
-    emit syncInProgressChanged(syncInProgress());
+    _missionController.managerVehicleChanged(_managerVehicle);
+    _geoFenceController.managerVehicleChanged(_managerVehicle);
+    _rallyPointController.managerVehicleChanged(_managerVehicle);
 
-    emit vehicleChanged(_activeVehicle);
+    if (!_editMode && _offline) {
+        // Fly view has changed to a new active vehicle
+        loadFromVehicle();
+    }
+
+    // Whenever manager changes we need to update syncInProgress
+    emit syncInProgressChanged(syncInProgress());
 }
 
 void PlanMasterController::loadFromVehicle(void)
@@ -96,6 +110,7 @@ void PlanMasterController::loadFromVehicle(void)
     _missionController.loadFromVehicle();
     _geoFenceController.loadFromVehicle();
     _rallyPointController.loadFromVehicle();
+    setDirty(false);
 }
 
 void PlanMasterController::sendToVehicle(void)
@@ -104,6 +119,7 @@ void PlanMasterController::sendToVehicle(void)
     _missionController.sendToVehicle();
     _geoFenceController.sendToVehicle();
     _rallyPointController.sendToVehicle();
+    setDirty(false);
 }
 
 
@@ -166,7 +182,7 @@ void PlanMasterController::loadFromFile(const QString& filename)
         }
     }
 
-    if (!_activeVehicle->isOfflineEditingVehicle()) {
+    if (!offline()) {
         setDirty(true);
     }
 }
@@ -204,8 +220,8 @@ void PlanMasterController::saveToFile(const QString& filename)
         file.write(saveDoc.toJson());
     }
 
-    // If we are connected to a real vehicle, don't clear dirty bit on saving to file since vehicle is still out of date
-    if (_activeVehicle->isOfflineEditingVehicle()) {
+    // Only clear dirty bit if we are offline
+    if (offline()) {
         setDirty(false);
     }
 }
@@ -234,6 +250,7 @@ bool PlanMasterController::syncInProgress(void) const
 
 bool PlanMasterController::dirty(void) const
 {
+    qDebug() << _editMode << _missionController.dirty() << _geoFenceController.dirty() << _rallyPointController.dirty();
     return _missionController.dirty() || _geoFenceController.dirty() || _rallyPointController.dirty();
 }
 

src/MissionManager/PlanMasterController.h

@@ -30,13 +30,14 @@ public:
     Q_PROPERTY(GeoFenceController*      geoFenceController      READ geoFenceController     CONSTANT)
     Q_PROPERTY(RallyPointController*    rallyPointController    READ rallyPointController   CONSTANT)
 
-    Q_PROPERTY(bool         containsItems   READ containsItems                  NOTIFY containsItemsChanged)    ///< true: Elemement is non-empty
-    Q_PROPERTY(bool         syncInProgress  READ syncInProgress                 NOTIFY syncInProgressChanged)   ///< true: Information is currently being saved/sent, false: no active save/send in progress
-    Q_PROPERTY(bool         dirty           READ dirty          WRITE setDirty  NOTIFY dirtyChanged)            ///< true: Unsaved/sent changes are present, false: no changes since last save/send
-    Q_PROPERTY(Vehicle*     vehicle         READ vehicle                        NOTIFY vehicleChanged)
-    Q_PROPERTY(QString      fileExtension   READ fileExtension                  CONSTANT)                       ///< File extention for missions
-    Q_PROPERTY(QStringList  loadNameFilters READ loadNameFilters                CONSTANT)                       ///< File filter list loading plan files
-    Q_PROPERTY(QStringList  saveNameFilters READ saveNameFilters                CONSTANT)                       ///< File filter list saving plan files
+    Q_PROPERTY(Vehicle*     controllerVehicle   MEMBER _controllerVehicle               CONSTANT)
+    Q_PROPERTY(bool         offline             READ offline                            NOTIFY offlineEditingChanged)   ///< true: controller is not connected to an active vehicle
+    Q_PROPERTY(bool         containsItems       READ containsItems                      NOTIFY containsItemsChanged)    ///< true: Elemement is non-empty
+    Q_PROPERTY(bool         syncInProgress      READ syncInProgress                     NOTIFY syncInProgressChanged)   ///< true: Information is currently being saved/sent, false: no active save/send in progress
+    Q_PROPERTY(bool         dirty               READ dirty              WRITE setDirty  NOTIFY dirtyChanged)            ///< true: Unsaved/sent changes are present, false: no changes since last save/send
+    Q_PROPERTY(QString      fileExtension       READ fileExtension                      CONSTANT)                       ///< File extention for missions
+    Q_PROPERTY(QStringList  loadNameFilters     READ loadNameFilters                    CONSTANT)                       ///< File filter list loading plan files
+    Q_PROPERTY(QStringList  saveNameFilters     READ saveNameFilters                    CONSTANT)                       ///< File filter list saving plan files
 
     /// Should be called immediately upon Component.onCompleted.
     ///     @param editMode true: controller being used in Plan view, false: controller being used in Fly view
@@ -61,6 +62,7 @@ public:
     GeoFenceController*     geoFenceController(void)    { return &_geoFenceController; }
     RallyPointController*   rallyPointController(void)  { return &_rallyPointController; }
 
+    bool        offline         (void) const { return _offline; }
     bool        containsItems   (void) const;
     bool        syncInProgress  (void) const;
     bool        dirty           (void) const;
@@ -69,21 +71,25 @@ public:
     QStringList loadNameFilters (void) const;
     QStringList saveNameFilters (void) const;
 
-    Vehicle* vehicle(void) { return _activeVehicle; }
+    Vehicle* controllerVehicle(void) { return _controllerVehicle; }
+    Vehicle* managerVehicle(void) { return _managerVehicle; }
 
 signals:
     void containsItemsChanged   (bool containsItems);
     void syncInProgressChanged  (bool syncInProgress);
     void dirtyChanged           (bool dirty);
     void vehicleChanged         (Vehicle* vehicle);
+    void offlineEditingChanged  (bool offlineEditing);
 
 private slots:
     void _activeVehicleChanged(Vehicle* activeVehicle);
 
 private:
     MultiVehicleManager*    _multiVehicleMgr;
-    Vehicle*                _activeVehicle;     ///< Currently active vehicle, can be disconnected offline editing vehicle
+    Vehicle*                _controllerVehicle;
+    Vehicle*                _managerVehicle;
     bool                    _editMode;
+    bool                    _offline;
     MissionController       _missionController;
     GeoFenceController      _geoFenceController;
     RallyPointController    _rallyPointController;

src/MissionManager/RallyPointController.cc

@@ -36,12 +36,15 @@ QGC_LOGGING_CATEGORY(RallyPointControllerLog, "RallyPointControllerLog")
 const char* RallyPointController::_jsonFileTypeValue =  "RallyPoints";
 const char* RallyPointController::_jsonPointsKey =      "points";
 
-RallyPointController::RallyPointController(QObject* parent)
-    : PlanElementController(parent)
+RallyPointController::RallyPointController(PlanMasterController* masterController, QObject* parent)
+    : PlanElementController(masterController, parent)
+    , _rallyPointManager(_managerVehicle->rallyPointManager())
     , _dirty(false)
     , _currentRallyPoint(NULL)
 {
     connect(&_points, &QmlObjectListModel::countChanged, this, &RallyPointController::_updateContainsItems);
+
+    managerVehicleChanged(_managerVehicle);
 }
 
 RallyPointController::~RallyPointController()
@@ -49,22 +52,26 @@ RallyPointController::~RallyPointController()
 
 }
 
-void RallyPointController::activeVehicleBeingRemoved(void)
+void RallyPointController::managerVehicleChanged(Vehicle* managerVehicle)
 {
-    _activeVehicle->rallyPointManager()->disconnect(this);
-    _points.clearAndDeleteContents();
-    _activeVehicle = NULL;
-}
+    if (_managerVehicle) {
+        _rallyPointManager->disconnect(this);
+        _managerVehicle = NULL;
+        _rallyPointManager = NULL;
+    }
 
-void RallyPointController::activeVehicleSet(Vehicle* activeVehicle)
-{
-    _activeVehicle = activeVehicle;
-    RallyPointManager* rallyPointManager = _activeVehicle->rallyPointManager();
-    connect(rallyPointManager, &RallyPointManager::loadComplete,        this, &RallyPointController::_loadComplete);
-    connect(rallyPointManager, &RallyPointManager::inProgressChanged,   this, &RallyPointController::syncInProgressChanged);
+    _managerVehicle = managerVehicle;
+    if (!_managerVehicle) {
+        qWarning() << "RallyPointController::managerVehicleChanged managerVehicle=NULL";
+        return;
+    }
+
+    _rallyPointManager = _managerVehicle->rallyPointManager();
+    connect(_rallyPointManager, &RallyPointManager::loadComplete,       this, &RallyPointController::_loadComplete);
+    connect(_rallyPointManager, &RallyPointManager::inProgressChanged,  this, &RallyPointController::syncInProgressChanged);
 
-    if (!rallyPointManager->inProgress()) {
-        _loadComplete(rallyPointManager->points());
+    if (!syncInProgress()) {
+        _loadComplete(_rallyPointManager->points());
     }
     emit rallyPointsSupportedChanged(rallyPointsSupported());
 }
@@ -121,10 +128,10 @@ void RallyPointController::removeAll(void)
 
 void RallyPointController::loadFromVehicle(void)
 {
-    if (_activeVehicle->parameterManager()->parametersReady() && !syncInProgress()) {
-        _activeVehicle->rallyPointManager()->loadFromVehicle();
+    if (!syncInProgress()) {
+        _rallyPointManager->loadFromVehicle();
     } else {
-        qCWarning(RallyPointControllerLog) << "RallyPointController::loadFromVehicle call at wrong time" << _activeVehicle->parameterManager()->parametersReady() << syncInProgress();
+        qCWarning(RallyPointControllerLog) << "RallyPointController::loadFromVehicle call while syncInProgress";
     }
 }
 
@@ -136,15 +143,15 @@ void RallyPointController::sendToVehicle(void)
         for (int i=0; i<_points.count(); i++) {
             rgPoints.append(qobject_cast<RallyPoint*>(_points[i])->coordinate());
         }
-        _activeVehicle->rallyPointManager()->sendToVehicle(rgPoints);
+        _rallyPointManager->sendToVehicle(rgPoints);
     } else {
-        qCWarning(RallyPointControllerLog) << "RallyPointController::loadFromVehicle call at wrong time" << _activeVehicle->parameterManager()->parametersReady() << syncInProgress();
+        qCWarning(RallyPointControllerLog) << "RallyPointController::loadFromVehicle while syncInProgress";
     }
 }
 
 bool RallyPointController::syncInProgress(void) const
 {
-    return _activeVehicle->rallyPointManager()->inProgress();
+    return _rallyPointManager->inProgress();
 }
 
 void RallyPointController::setDirty(bool dirty)
@@ -157,7 +164,7 @@ void RallyPointController::setDirty(bool dirty)
 
 QString RallyPointController::editorQml(void) const
 {
-    return _activeVehicle->rallyPointManager()->editorQml();
+    return _rallyPointManager->editorQml();
 }
 
 void RallyPointController::_loadComplete(const QList<QGeoCoordinate> rgPoints)
@@ -190,7 +197,7 @@ void RallyPointController::addPoint(QGeoCoordinate point)
 
 bool RallyPointController::rallyPointsSupported(void) const
 {
-    return _activeVehicle->rallyPointManager()->rallyPointsSupported();
+    return _rallyPointManager->rallyPointsSupported();
 }
 
 void RallyPointController::removePoint(QObject* rallyPoint)
@@ -237,5 +244,5 @@ void RallyPointController::_updateContainsItems(void)
 
 void RallyPointController::removeAllFromVehicle(void)
 {
-    _activeVehicle->rallyPointManager()->removeAll();
+    _rallyPointManager->removeAll();
 }

src/MissionManager/RallyPointController.h

@@ -26,7 +26,7 @@ class RallyPointController : public PlanElementController
     Q_OBJECT
     
 public:
-    RallyPointController(QObject* parent = NULL);
+    RallyPointController(PlanMasterController* masterController, QObject* parent = NULL);
     ~RallyPointController();
     
     Q_PROPERTY(bool                 rallyPointsSupported    READ rallyPointsSupported                               NOTIFY rallyPointsSupportedChanged)
@@ -47,8 +47,7 @@ public:
     bool dirty                  (void) const final { return _dirty; }
     void setDirty               (bool dirty) final;
     bool containsItems          (void) const final;
-    void activeVehicleBeingRemoved  (void) final;
-    void activeVehicleSet           (Vehicle* vehicle) final;
+    void managerVehicleChanged  (Vehicle* managerVehicle) final;
 
     bool                rallyPointsSupported    (void) const;
     QmlObjectListModel* points                  (void) { return &_points; }
@@ -68,6 +67,7 @@ private slots:
     void _updateContainsItems(void);
 
 private:
+    RallyPointManager*  _rallyPointManager;
     bool                _dirty;
     QmlObjectListModel  _points;
     QObject*            _currentRallyPoint;

src/PlanView/MissionItemEditor.qml

@@ -20,7 +20,7 @@ Rectangle {
     radius: _radius
 
     property var    map                 ///< Map control
-    property var    missionController
+    property var    masterController
     property var    missionItem         ///< MissionItem associated with this editor
     property bool   readOnly            ///< true: read only view, false: full editing view
     property var    rootQgcView
@@ -30,11 +30,13 @@ Rectangle {
     signal insertWaypoint
     signal insertComplexItem(string complexItemName)
 
+    property var    _masterController:          masterController
+    property var    _missionController:         _masterController.missionController
     property bool   _currentItem:               missionItem.isCurrentItem
     property color  _outerTextColor:            _currentItem ? qgcPal.primaryButtonText : qgcPal.text
     property bool   _noMissionItemsAdded:       ListView.view.model.count === 1
     property real   _sectionSpacer:             ScreenTools.defaultFontPixelWidth / 2  // spacing between section headings
-    property bool   _singleComplexItem:         missionController.complexMissionItemNames.length === 1
+    property bool   _singleComplexItem:         _missionController.complexMissionItemNames.length === 1
 
     readonly property real  _editFieldWidth:    Math.min(width - _margin * 2, ScreenTools.defaultFontPixelWidth * 12)
     readonly property real  _margin:            ScreenTools.defaultFontPixelWidth / 2
@@ -105,7 +107,7 @@ Rectangle {
                 visible:    !_singleComplexItem
 
                 Instantiator {
-                    model: missionController.complexMissionItemNames
+                    model: _missionController.complexMissionItemNames
 
                     onObjectAdded:      patternMenu.insertItem(index, object)
                     onObjectRemoved:    patternMenu.removeItem(object)
@@ -118,9 +120,9 @@ Rectangle {
             }
 
             MenuItem {
-                text:           qsTr("Insert ") + missionController.complexMissionItemNames[0]
+                text:           qsTr("Insert ") + _missionController.complexMissionItemNames[0]
                 visible:        _singleComplexItem
-                onTriggered:    insertComplexItem(missionController.complexMissionItemNames[0])
+                onTriggered:    insertComplexItem(_missionController.complexMissionItemNames[0])
             }
 
             MenuItem {
@@ -203,7 +205,8 @@ Rectangle {
             item.visible = Qt.binding(function() { return _currentItem; })
         }
 
-        property real   availableWidth: _root.width - (_margin * 2) ///< How wide the editor should be
-        property var    editorRoot:     _root
+        property var    masterController:   _masterController
+        property real   availableWidth:     _root.width - (_margin * 2) ///< How wide the editor should be
+        property var    editorRoot:         _root
     }
 } // Rectangle

src/PlanView/MissionSettingsEditor.qml

@@ -20,7 +20,9 @@ Rectangle {
     visible:            missionItem.isCurrentItem
     radius:             _radius
 
-    property var    _missionVehicle:            missionController.vehicle
+    property var    _masterControler:           masterController
+    property var    _missionController:         _masterControler.missionController
+    property var    _missionVehicle:            _masterControler.controllerVehicle
     property bool   _vehicleHasHomePosition:    _missionVehicle.homePosition.isValid
     property bool   _offlineEditing:            _missionVehicle.isOfflineEditingVehicle
     property bool   _showOfflineVehicleCombos:  _offlineEditing && _multipleFirmware && _noMissionItemsAdded
@@ -32,7 +34,7 @@ Rectangle {
     property var    _savePath:                  QGroundControl.settingsManager.appSettings.missionSavePath
     property var    _fileExtension:             QGroundControl.settingsManager.appSettings.missionFileExtension
     property var    _appSettings:               QGroundControl.settingsManager.appSettings    
-    property bool   _waypointsOnlyMode:          QGroundControl.corePlugin.options.missionWaypointsOnly
+    property bool   _waypointsOnlyMode:         QGroundControl.corePlugin.options.missionWaypointsOnly
 
     readonly property string _firmwareLabel:    qsTr("Firmware")
     readonly property string _vehicleLabel:     qsTr("Vehicle")

src/PlanView/PlanToolBar.qml

@@ -273,8 +273,8 @@ Rectangle {
         anchors.right:          parent.right
         anchors.verticalCenter: parent.verticalCenter
         text:                   _controllerDirty ? qsTr("Upload Required") : qsTr("Upload")
-        enabled:                _activeVehicle && !_controllerSyncInProgress
-        visible:                _activeVehicle
+        enabled:                !_controllerSyncInProgress
+        visible:                !planMasterController.offline
         onClicked:              planMasterController.upload()
 
         PropertyAnimation on opacity {

src/PlanView/PlanView.qml

@@ -557,7 +557,7 @@ QGCView {
 
                     delegate: MissionItemEditor {
                         map:                editorMap
-                        missionController:  _missionController
+                        masterController:  _planMasterController
                         missionItem:        object
                         width:              parent.width
                         readOnly:           false
@@ -734,7 +734,7 @@ QGCView {
                 QGCButton {
                     text:               qsTr("Upload")
                     Layout.fillWidth:   true
-                    enabled:            _activeVehicle && !masterController.syncInProgress
+                    enabled:            !masterController.offline && !masterController.syncInProgress
                     onClicked: {
                         dropPanel.hide()
                         masterController.upload()
@@ -744,7 +744,7 @@ QGCView {
                 QGCButton {
                     text:               qsTr("Download")
                     Layout.fillWidth:   true
-                    enabled:            _activeVehicle && !masterController.syncInProgress
+                    enabled:            !masterController.offline && !masterController.syncInProgress
                     onClicked: {
                         dropPanel.hide()
                         if (masterController.dirty) {

src/QGCApplication.cc

@@ -378,14 +378,14 @@ void QGCApplication::_initCommon(void)
     qmlRegisterUncreatableType<Joystick>            ("QGroundControl.JoystickManager",      1, 0, "Joystick",               "Reference only");
     qmlRegisterUncreatableType<QGCPositionManager>  ("QGroundControl.QGCPositionManager",   1, 0, "QGCPositionManager",     "Reference only");
     qmlRegisterUncreatableType<QGCMapPolygon>       ("QGroundControl.FlightMap",            1, 0, "QGCMapPolygon",          "Reference only");
+    qmlRegisterUncreatableType<MissionController>   ("QGroundControl.Controllers",          1, 0, "MissionController",      "Reference only");
+    qmlRegisterUncreatableType<GeoFenceController>  ("QGroundControl.Controllers",          1, 0, "GeoFenceController",     "Reference only");
+    qmlRegisterUncreatableType<RallyPointController>("QGroundControl.Controllers",          1, 0, "RallyPointController",    "Reference only");
 
     qmlRegisterType<ParameterEditorController>          ("QGroundControl.Controllers", 1, 0, "ParameterEditorController");
     qmlRegisterType<ESP8266ComponentController>         ("QGroundControl.Controllers", 1, 0, "ESP8266ComponentController");
     qmlRegisterType<ScreenToolsController>              ("QGroundControl.Controllers", 1, 0, "ScreenToolsController");
     qmlRegisterType<PlanMasterController>        ("QGroundControl.Controllers", 1, 0, "PlanElemementMasterController");
-    qmlRegisterType<MissionController>                  ("QGroundControl.Controllers", 1, 0, "MissionController");
-    qmlRegisterType<GeoFenceController>                 ("QGroundControl.Controllers", 1, 0, "GeoFenceController");
-    qmlRegisterType<RallyPointController>               ("QGroundControl.Controllers", 1, 0, "RallyPointController");
     qmlRegisterType<ValuesWidgetController>             ("QGroundControl.Controllers", 1, 0, "ValuesWidgetController");
     qmlRegisterType<QFileDialogController>      ("QGroundControl.Controllers", 1, 0, "QFileDialogController");
     qmlRegisterType<RCChannelMonitorController>         ("QGroundControl.Controllers", 1, 0, "RCChannelMonitorController");

src/Settings/AppSettings.cc

@@ -289,3 +289,26 @@ Fact* AppSettings::automaticMissionUpload(void)
     return _automaticMissionUpload;
 }
 
+MAV_AUTOPILOT AppSettings::offlineEditingFirmwareTypeFromFirmwareType(MAV_AUTOPILOT firmwareType)
+{
+    if (firmwareType != MAV_AUTOPILOT_PX4 && firmwareType != MAV_AUTOPILOT_ARDUPILOTMEGA) {
+        firmwareType = MAV_AUTOPILOT_GENERIC;
+    }
+    return firmwareType;
+}
+
+MAV_TYPE AppSettings::offlineEditingVehicleTypeFromVehicleType(MAV_TYPE vehicleType)
+{
+    if (QGCMAVLink::isRover(vehicleType)) {
+        return MAV_TYPE_GROUND_ROVER;
+    } else if (QGCMAVLink::isSub(vehicleType)) {
+        return MAV_TYPE_SUBMARINE;
+    } else if (QGCMAVLink::isVTOL(vehicleType)) {
+        return MAV_TYPE_VTOL_QUADROTOR;
+    } else if (QGCMAVLink::isFixedWing(vehicleType)) {
+        return MAV_TYPE_FIXED_WING;
+    } else {
+        return MAV_TYPE_QUADROTOR;
+    }
+}
+

src/Settings/AppSettings.h

@@ -11,6 +11,7 @@
 #define AppSettings_H
 
 #include "SettingsGroup.h"
+#include "QGCMAVLink.h"
 
 class AppSettings : public SettingsGroup
 {
@@ -67,6 +68,9 @@ public:
     QString parameterSavePath   (void);
     QString telemetrySavePath   (void);
 
+    static MAV_AUTOPILOT offlineEditingFirmwareTypeFromFirmwareType(MAV_AUTOPILOT firmwareType);
+    static MAV_TYPE offlineEditingVehicleTypeFromVehicleType(MAV_TYPE vehicleType);
+
     static const char* appSettingsGroupName;
 
     static const char* offlineEditingFirmwareTypeSettingsName;