PlanMasterController.cc 24.6 KB
Newer Older
1 2
/****************************************************************************
 *
Gus Grubba's avatar
Gus Grubba committed
3
 * (c) 2009-2020 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
4 5 6 7 8 9 10 11
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/

#include "PlanMasterController.h"
#include "QGCApplication.h"
12
#include "QGCCorePlugin.h"
13
#include "MultiVehicleManager.h"
14
#include "SettingsManager.h"
15 16
#include "AppSettings.h"
#include "JsonHelper.h"
17
#include "MissionManager.h"
18
#include "KML.h"
DonLakeFlyer's avatar
DonLakeFlyer committed
19 20 21
#include "SurveyPlanCreator.h"
#include "StructureScanPlanCreator.h"
#include "CorridorScanPlanCreator.h"
22
#include "BlankPlanCreator.h"
23 24 25
#if defined(QGC_AIRMAP_ENABLED)
#include "AirspaceFlightPlanProvider.h"
#endif
26

27
#include <QDomDocument>
28
#include <QJsonDocument>
Don Gagne's avatar
Don Gagne committed
29
#include <QFileInfo>
30

DonLakeFlyer's avatar
DonLakeFlyer committed
31 32
QGC_LOGGING_CATEGORY(PlanMasterControllerLog, "PlanMasterControllerLog")

33 34 35 36 37
const int   PlanMasterController::kPlanFileVersion =            1;
const char* PlanMasterController::kPlanFileType =               "Plan";
const char* PlanMasterController::kJsonMissionObjectKey =       "mission";
const char* PlanMasterController::kJsonGeoFenceObjectKey =      "geoFence";
const char* PlanMasterController::kJsonRallyPointsObjectKey =   "rallyPoints";
38 39

PlanMasterController::PlanMasterController(QObject* parent)
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
    : QObject               (parent)
    , _multiVehicleMgr      (qgcApp()->toolbox()->multiVehicleManager())
    , _controllerVehicle    (new Vehicle(
                                 static_cast<MAV_AUTOPILOT>(qgcApp()->toolbox()->settingsManager()->appSettings()->offlineEditingFirmwareType()->rawValue().toInt()),
                                 static_cast<MAV_TYPE>(qgcApp()->toolbox()->settingsManager()->appSettings()->offlineEditingVehicleType()->rawValue().toInt()),
                                 qgcApp()->toolbox()->firmwarePluginManager(),
                                 this))
    , _managerVehicle       (_controllerVehicle)
    , _missionController    (this)
    , _geoFenceController   (this)
    , _rallyPointController (this)
{
    _commonInit();
}

#ifdef QT_DEBUG
PlanMasterController::PlanMasterController(MAV_AUTOPILOT firmwareType, MAV_TYPE vehicleType, QObject* parent)
    : QObject               (parent)
    , _multiVehicleMgr      (qgcApp()->toolbox()->multiVehicleManager())
    , _controllerVehicle    (new Vehicle(firmwareType, vehicleType, qgcApp()->toolbox()->firmwarePluginManager()))
    , _managerVehicle       (_controllerVehicle)
    , _missionController    (this)
    , _geoFenceController   (this)
    , _rallyPointController (this)
{
    _commonInit();
}
#endif

void PlanMasterController::_commonInit(void)
70 71 72 73 74 75 76 77 78 79 80 81
{
    connect(&_missionController,    &MissionController::dirtyChanged,       this, &PlanMasterController::dirtyChanged);
    connect(&_geoFenceController,   &GeoFenceController::dirtyChanged,      this, &PlanMasterController::dirtyChanged);
    connect(&_rallyPointController, &RallyPointController::dirtyChanged,    this, &PlanMasterController::dirtyChanged);

    connect(&_missionController,    &MissionController::containsItemsChanged,       this, &PlanMasterController::containsItemsChanged);
    connect(&_geoFenceController,   &GeoFenceController::containsItemsChanged,      this, &PlanMasterController::containsItemsChanged);
    connect(&_rallyPointController, &RallyPointController::containsItemsChanged,    this, &PlanMasterController::containsItemsChanged);

    connect(&_missionController,    &MissionController::syncInProgressChanged,      this, &PlanMasterController::syncInProgressChanged);
    connect(&_geoFenceController,   &GeoFenceController::syncInProgressChanged,     this, &PlanMasterController::syncInProgressChanged);
    connect(&_rallyPointController, &RallyPointController::syncInProgressChanged,   this, &PlanMasterController::syncInProgressChanged);
82 83 84 85 86 87 88

    // Offline vehicle can change firmware/vehicle type
    connect(_controllerVehicle, &Vehicle::capabilityBitsChanged,    this, &PlanMasterController::_updateSupportsTerrain);
    connect(_controllerVehicle, &Vehicle::vehicleTypeChanged,       this, &PlanMasterController::_updateSupportsTerrain);
    connect(_controllerVehicle, &Vehicle::vehicleTypeChanged,       this, &PlanMasterController::_updatePlanCreatorsList);

    _updateSupportsTerrain();
89 90
}

91

92 93 94 95 96
PlanMasterController::~PlanMasterController()
{

}

97
void PlanMasterController::start(bool flyView)
98
{
99 100 101 102
    _flyView = flyView;
    _missionController.start(_flyView);
    _geoFenceController.start(_flyView);
    _rallyPointController.start(_flyView);
103 104

    _activeVehicleChanged(_multiVehicleMgr->activeVehicle());
105
    connect(_multiVehicleMgr, &MultiVehicleManager::activeVehicleChanged, this, &PlanMasterController::_activeVehicleChanged);
106

DonLakeFlyer's avatar
DonLakeFlyer committed
107 108
    _updatePlanCreatorsList();

109 110
#if defined(QGC_AIRMAP_ENABLED)
    //-- This assumes there is one single instance of PlanMasterController in edit mode.
111
    if(!flyView) {
112 113
        // Wait for signal confirming AirMap client connection before starting flight planning
        connect(qgcApp()->toolbox()->airspaceManager(), &AirspaceManager::connectStatusChanged, this, &PlanMasterController::_startFlightPlanning);
114 115
    }
#endif
116 117
}

118
void PlanMasterController::startStaticActiveVehicle(Vehicle* vehicle, bool deleteWhenSendCompleted)
119
{
120
    _flyView = true;
121
    _deleteWhenSendCompleted = deleteWhenSendCompleted;
122 123 124
    _missionController.start(_flyView);
    _geoFenceController.start(_flyView);
    _rallyPointController.start(_flyView);
125 126 127 128 129
    _activeVehicleChanged(vehicle);
}

void PlanMasterController::_activeVehicleChanged(Vehicle* activeVehicle)
{
130 131 132
    if (_managerVehicle == activeVehicle) {
        // We are already setup for this vehicle
        return;
133 134
    }

DonLakeFlyer's avatar
DonLakeFlyer committed
135 136
    qCDebug(PlanMasterControllerLog) << "_activeVehicleChanged" << activeVehicle;

137
    if (_managerVehicle) {
138 139 140 141 142
        // Disconnect old vehicle. Be careful of wildcarding disconnect too much since _managerVehicle may equal _controllerVehicle
        disconnect(_managerVehicle->missionManager(),       nullptr, nullptr, nullptr);
        disconnect(_managerVehicle->geoFenceManager(),      nullptr, nullptr, nullptr);
        disconnect(_managerVehicle->rallyPointManager(),    nullptr, nullptr, nullptr);
        disconnect(_managerVehicle,                         &Vehicle::capabilityBitsChanged, this, &PlanMasterController::_updateSupportsTerrain);
143 144
    }

145
    bool newOffline = false;
146
    if (activeVehicle == nullptr) {
147 148 149
        // Since there is no longer an active vehicle we use the offline controller vehicle as the manager vehicle
        _managerVehicle = _controllerVehicle;
        newOffline = true;
150
    } else {
151
        newOffline = false;
152 153 154 155 156 157 158 159
        _managerVehicle = activeVehicle;

        // Update controllerVehicle to the currently connected vehicle
        AppSettings* appSettings = qgcApp()->toolbox()->settingsManager()->appSettings();
        appSettings->offlineEditingFirmwareType()->setRawValue(AppSettings::offlineEditingFirmwareTypeFromFirmwareType(_managerVehicle->firmwareType()));
        appSettings->offlineEditingVehicleType()->setRawValue(AppSettings::offlineEditingVehicleTypeFromVehicleType(_managerVehicle->vehicleType()));

        // We use these signals to sequence upload and download to the multiple controller/managers
DonLakeFlyer's avatar
DonLakeFlyer committed
160 161 162 163 164 165
        connect(_managerVehicle->missionManager(),      &MissionManager::newMissionItemsAvailable,  this, &PlanMasterController::_loadMissionComplete);
        connect(_managerVehicle->geoFenceManager(),     &GeoFenceManager::loadComplete,             this, &PlanMasterController::_loadGeoFenceComplete);
        connect(_managerVehicle->rallyPointManager(),   &RallyPointManager::loadComplete,           this, &PlanMasterController::_loadRallyPointsComplete);
        connect(_managerVehicle->missionManager(),      &MissionManager::sendComplete,              this, &PlanMasterController::_sendMissionComplete);
        connect(_managerVehicle->geoFenceManager(),     &GeoFenceManager::sendComplete,             this, &PlanMasterController::_sendGeoFenceComplete);
        connect(_managerVehicle->rallyPointManager(),   &RallyPointManager::sendComplete,           this, &PlanMasterController::_sendRallyPointsComplete);
166
    }
167

168 169 170 171
    // Change in capabilities will affect terrain support
    connect(_managerVehicle, &Vehicle::capabilityBitsChanged, this, &PlanMasterController::_updateSupportsTerrain);

    emit managerVehicleChanged(_managerVehicle);
172

173 174 175 176 177 178
    // Vehicle changed so we need to signal everything
    _offline = newOffline;
    emit containsItemsChanged(containsItems());
    emit syncInProgressChanged();
    emit dirtyChanged(dirty());
    emit offlineChanged(offline());
179
    _updateSupportsTerrain();
180

181
    if (!_flyView) {
DonLakeFlyer's avatar
DonLakeFlyer committed
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
        if (!offline()) {
            // We are in Plan view and we have a newly connected vehicle:
            //  - If there is no plan available in Plan view show the one from the vehicle
            //  - Otherwise leave the current plan alone
            if (!containsItems()) {
                qCDebug(PlanMasterControllerLog) << "_activeVehicleChanged: Plan view is empty so loading from manager";
                _showPlanFromManagerVehicle();
            }
        }
    } else {
        if (offline()) {
            // No more active vehicle, clear mission
            qCDebug(PlanMasterControllerLog) << "_activeVehicleChanged: Fly view is offline clearing plan";
            removeAll();
        } else {
            // Fly view has changed to a new active vehicle, update to show correct mission
            qCDebug(PlanMasterControllerLog) << "_activeVehicleChanged: Fly view is online so loading from manager";
            _showPlanFromManagerVehicle();
        }
201
    }
DonLakeFlyer's avatar
DonLakeFlyer committed
202 203

    _updatePlanCreatorsList();
204 205 206 207
}

void PlanMasterController::loadFromVehicle(void)
{
208 209 210 211 212
    if (_managerVehicle->highLatencyLink()) {
        qgcApp()->showMessage(tr("Download not supported on high latency links."));
        return;
    }

DonLakeFlyer's avatar
DonLakeFlyer committed
213 214
    if (offline()) {
        qCWarning(PlanMasterControllerLog) << "PlanMasterController::loadFromVehicle called while offline";
215
    } else if (_flyView) {
DonLakeFlyer's avatar
DonLakeFlyer committed
216 217 218 219
        qCWarning(PlanMasterControllerLog) << "PlanMasterController::loadFromVehicle called from Fly view";
    } else if (syncInProgress()) {
        qCWarning(PlanMasterControllerLog) << "PlanMasterController::loadFromVehicle called while syncInProgress";
    } else {
220
        _loadGeoFence = true;
221
        qCDebug(PlanMasterControllerLog) << "PlanMasterController::loadFromVehicle calling _missionController.loadFromVehicle";
222 223 224
        _missionController.loadFromVehicle();
        setDirty(false);
    }
225 226
}

227

DonLakeFlyer's avatar
DonLakeFlyer committed
228
void PlanMasterController::_loadMissionComplete(void)
229
{
230
    if (!_flyView && _loadGeoFence) {
231 232
        _loadGeoFence = false;
        _loadRallyPoints = true;
233
        if (_geoFenceController.supported()) {
234
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::_loadMissionComplete calling _geoFenceController.loadFromVehicle";
235 236 237 238 239 240
            _geoFenceController.loadFromVehicle();
        } else {
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::_loadMissionComplete GeoFence not supported skipping";
            _geoFenceController.removeAll();
            _loadGeoFenceComplete();
        }
241
        setDirty(false);
DonLakeFlyer's avatar
DonLakeFlyer committed
242 243 244 245 246
    }
}

void PlanMasterController::_loadGeoFenceComplete(void)
{
247
    if (!_flyView && _loadRallyPoints) {
DonLakeFlyer's avatar
DonLakeFlyer committed
248
        _loadRallyPoints = false;
249
        if (_rallyPointController.supported()) {
250
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::_loadGeoFenceComplete calling _rallyPointController.loadFromVehicle";
251 252 253 254 255 256
            _rallyPointController.loadFromVehicle();
        } else {
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::_loadMissionComplete Rally Points not supported skipping";
            _rallyPointController.removeAll();
            _loadRallyPointsComplete();
        }
DonLakeFlyer's avatar
DonLakeFlyer committed
257 258 259 260 261 262
        setDirty(false);
    }
}

void PlanMasterController::_loadRallyPointsComplete(void)
{
263
    qCDebug(PlanMasterControllerLog) << "PlanMasterController::_loadRallyPointsComplete";
DonLakeFlyer's avatar
DonLakeFlyer committed
264 265 266 267
}

void PlanMasterController::_sendMissionComplete(void)
{
268
    if (_sendGeoFence) {
269 270
        _sendGeoFence = false;
        _sendRallyPoints = true;
271 272 273 274 275 276 277
        if (_geoFenceController.supported()) {
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle start GeoFence sendToVehicle";
            _geoFenceController.sendToVehicle();
        } else {
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle GeoFence not supported skipping";
            _sendGeoFenceComplete();
        }
278 279 280 281
        setDirty(false);
    }
}

DonLakeFlyer's avatar
DonLakeFlyer committed
282
void PlanMasterController::_sendGeoFenceComplete(void)
283
{
284
    if (_sendRallyPoints) {
285
        _sendRallyPoints = false;
286 287 288 289 290 291 292
        if (_rallyPointController.supported()) {
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle start rally sendToVehicle";
            _rallyPointController.sendToVehicle();
        } else {
            qCDebug(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle Rally Points not support skipping";
            _sendRallyPointsComplete();
        }
293 294 295
    }
}

DonLakeFlyer's avatar
DonLakeFlyer committed
296 297
void PlanMasterController::_sendRallyPointsComplete(void)
{
298
    qCDebug(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle Rally Point send complete";
299 300 301
    if (_deleteWhenSendCompleted) {
        this->deleteLater();
    }
DonLakeFlyer's avatar
DonLakeFlyer committed
302 303
}

304
#if defined(QGC_AIRMAP_ENABLED)
305
void PlanMasterController::_startFlightPlanning(void) {
306 307 308 309
    if (qgcApp()->toolbox()->airspaceManager()->connected()) {
        qCDebug(PlanMasterControllerLog) << "PlanMasterController::_startFlightPlanning client connected, start flight planning";
        qgcApp()->toolbox()->airspaceManager()->flightPlan()->startFlightPlanning(this);
    }
310
}
311
#endif
312

313 314
void PlanMasterController::sendToVehicle(void)
{
315 316 317 318 319
    if (_managerVehicle->highLatencyLink()) {
        qgcApp()->showMessage(tr("Upload not supported on high latency links."));
        return;
    }

DonLakeFlyer's avatar
DonLakeFlyer committed
320 321 322 323 324 325
    if (offline()) {
        qCWarning(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle called while offline";
    } else if (syncInProgress()) {
        qCWarning(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle called while syncInProgress";
    } else {
        qCDebug(PlanMasterControllerLog) << "PlanMasterController::sendToVehicle start mission sendToVehicle";
326 327 328 329
        _sendGeoFence = true;
        _missionController.sendToVehicle();
        setDirty(false);
    }
330 331 332 333 334
}

void PlanMasterController::loadFromFile(const QString& filename)
{
    QString errorString;
335
    QString errorMessage = tr("Error loading Plan file (%1). %2").arg(filename).arg("%1");
336 337 338 339 340

    if (filename.isEmpty()) {
        return;
    }

341
    QFileInfo fileInfo(filename);
342 343 344 345
    QFile file(filename);

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        errorString = file.errorString() + QStringLiteral(" ") + filename;
346
        qgcApp()->showMessage(errorMessage.arg(errorString));
347 348 349
        return;
    }

350 351
    bool success = false;
    if(fileInfo.suffix() == AppSettings::planFileExtension) {
352 353 354 355 356 357 358 359 360
        QJsonDocument   jsonDoc;
        QByteArray      bytes = file.readAll();

        if (!JsonHelper::isJsonFile(bytes, jsonDoc, errorString)) {
            qgcApp()->showMessage(errorMessage.arg(errorString));
            return;
        }

        QJsonObject json = jsonDoc.object();
361 362 363 364 365
        //-- Allow plugins to pre process the load
        qgcApp()->toolbox()->corePlugin()->preLoadFromJson(this, json);

        int version;
        if (!JsonHelper::validateQGCJsonFile(json, kPlanFileType, kPlanFileVersion, kPlanFileVersion, version, errorString)) {
366 367 368 369 370
            qgcApp()->showMessage(errorMessage.arg(errorString));
            return;
        }

        QList<JsonHelper::KeyValidateInfo> rgKeyInfo = {
371 372 373
            { kJsonMissionObjectKey,        QJsonValue::Object, true },
            { kJsonGeoFenceObjectKey,       QJsonValue::Object, true },
            { kJsonRallyPointsObjectKey,    QJsonValue::Object, true },
374 375 376 377 378 379
        };
        if (!JsonHelper::validateKeys(json, rgKeyInfo, errorString)) {
            qgcApp()->showMessage(errorMessage.arg(errorString));
            return;
        }

380 381 382
        if (!_missionController.load(json[kJsonMissionObjectKey].toObject(), errorString) ||
                !_geoFenceController.load(json[kJsonGeoFenceObjectKey].toObject(), errorString) ||
                !_rallyPointController.load(json[kJsonRallyPointsObjectKey].toObject(), errorString)) {
383
            qgcApp()->showMessage(errorMessage.arg(errorString));
384
        } else {
385 386
            //-- Allow plugins to post process the load
            qgcApp()->toolbox()->corePlugin()->postLoadFromJson(this, json);
387
            success = true;
388
        }
389
    } else if (fileInfo.suffix() == AppSettings::missionFileExtension) {
390 391
        if (!_missionController.loadJsonFile(file, errorString)) {
            qgcApp()->showMessage(errorMessage.arg(errorString));
392 393
        } else {
            success = true;
394
        }
395
    } else if (fileInfo.suffix() == AppSettings::waypointsFileExtension || fileInfo.suffix() == QStringLiteral("txt")) {
396 397
        if (!_missionController.loadTextFile(file, errorString)) {
            qgcApp()->showMessage(errorMessage.arg(errorString));
398 399
        } else {
            success = true;
400
        }
401 402 403 404 405 406 407 408
    } else {
        //-- TODO: What then?
    }

    if(success){
        _currentPlanFile.sprintf("%s/%s.%s", fileInfo.path().toLocal8Bit().data(), fileInfo.completeBaseName().toLocal8Bit().data(), AppSettings::planFileExtension);
    } else {
        _currentPlanFile.clear();
409
    }
410
    emit currentPlanFileChanged();
411

412
    if (!offline()) {
413
        setDirty(true);
414 415 416
    }
}

Gus Grubba's avatar
Gus Grubba committed
417 418 419
QJsonDocument PlanMasterController::saveToJson()
{
    QJsonObject planJson;
420
    qgcApp()->toolbox()->corePlugin()->preSaveToJson(this, planJson);
Gus Grubba's avatar
Gus Grubba committed
421 422 423
    QJsonObject missionJson;
    QJsonObject fenceJson;
    QJsonObject rallyJson;
424 425 426
    JsonHelper::saveQGCJsonFileHeader(planJson, kPlanFileType, kPlanFileVersion);
    //-- Allow plugin to preemptly add its own keys to mission
    qgcApp()->toolbox()->corePlugin()->preSaveToMissionJson(this, missionJson);
Gus Grubba's avatar
Gus Grubba committed
427
    _missionController.save(missionJson);
428 429
    //-- Allow plugin to add its own keys to mission
    qgcApp()->toolbox()->corePlugin()->postSaveToMissionJson(this, missionJson);
Gus Grubba's avatar
Gus Grubba committed
430 431
    _geoFenceController.save(fenceJson);
    _rallyPointController.save(rallyJson);
432 433 434 435
    planJson[kJsonMissionObjectKey] = missionJson;
    planJson[kJsonGeoFenceObjectKey] = fenceJson;
    planJson[kJsonRallyPointsObjectKey] = rallyJson;
    qgcApp()->toolbox()->corePlugin()->postSaveToJson(this, planJson);
Gus Grubba's avatar
Gus Grubba committed
436 437 438
    return QJsonDocument(planJson);
}

439 440 441 442 443 444 445 446
void
PlanMasterController::saveToCurrent()
{
    if(!_currentPlanFile.isEmpty()) {
        saveToFile(_currentPlanFile);
    }
}

447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
void PlanMasterController::saveToFile(const QString& filename)
{
    if (filename.isEmpty()) {
        return;
    }

    QString planFilename = filename;
    if (!QFileInfo(filename).fileName().contains(".")) {
        planFilename += QString(".%1").arg(fileExtension());
    }

    QFile file(planFilename);

    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qgcApp()->showMessage(tr("Plan save error %1 : %2").arg(filename).arg(file.errorString()));
462 463
        _currentPlanFile.clear();
        emit currentPlanFileChanged();
464
    } else {
Gus Grubba's avatar
Gus Grubba committed
465
        QJsonDocument saveDoc = saveToJson();
466
        file.write(saveDoc.toJson());
467 468 469 470
        if(_currentPlanFile != planFilename) {
            _currentPlanFile = planFilename;
            emit currentPlanFileChanged();
        }
471 472
    }

473 474
    // Only clear dirty bit if we are offline
    if (offline()) {
475 476 477 478
        setDirty(false);
    }
}

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
void PlanMasterController::saveToKml(const QString& filename)
{
    if (filename.isEmpty()) {
        return;
    }

    QString kmlFilename = filename;
    if (!QFileInfo(filename).fileName().contains(".")) {
        kmlFilename += QString(".%1").arg(kmlFileExtension());
    }

    QFile file(kmlFilename);

    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
        qgcApp()->showMessage(tr("KML save error %1 : %2").arg(filename).arg(file.errorString()));
    } else {
        QDomDocument domDocument;
        _missionController.convertToKMLDocument(domDocument);
        QTextStream stream(&file);
        stream << domDocument.toString();
        file.close();
    }
}

503 504
void PlanMasterController::removeAll(void)
{
505 506 507
    _missionController.removeAll();
    _geoFenceController.removeAll();
    _rallyPointController.removeAll();
508 509 510 511
    if (_offline) {
        _missionController.setDirty(false);
        _geoFenceController.setDirty(false);
        _rallyPointController.setDirty(false);
512 513
        _currentPlanFile.clear();
        emit currentPlanFileChanged();
514
    }
515 516 517 518
}

void PlanMasterController::removeAllFromVehicle(void)
{
519 520
    if (!offline()) {
        _missionController.removeAllFromVehicle();
521 522 523 524 525 526
        if (_geoFenceController.supported()) {
            _geoFenceController.removeAllFromVehicle();
        }
        if (_rallyPointController.supported()) {
            _rallyPointController.removeAllFromVehicle();
        }
527
        setDirty(false);
528 529 530
    } else {
        qWarning() << "PlanMasterController::removeAllFromVehicle called while offline";
    }
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
}

bool PlanMasterController::containsItems(void) const
{
    return _missionController.containsItems() || _geoFenceController.containsItems() || _rallyPointController.containsItems();
}

bool PlanMasterController::dirty(void) const
{
    return _missionController.dirty() || _geoFenceController.dirty() || _rallyPointController.dirty();
}

void PlanMasterController::setDirty(bool dirty)
{
    _missionController.setDirty(dirty);
    _geoFenceController.setDirty(dirty);
    _rallyPointController.setDirty(dirty);
}

QString PlanMasterController::fileExtension(void) const
{
    return AppSettings::planFileExtension;
}

555 556 557 558 559
QString PlanMasterController::kmlFileExtension(void) const
{
    return AppSettings::kmlFileExtension;
}

560 561 562 563
QStringList PlanMasterController::loadNameFilters(void) const
{
    QStringList filters;

Don Gagne's avatar
Don Gagne committed
564
    filters << tr("Supported types (*.%1 *.%2 *.%3 *.%4)").arg(AppSettings::planFileExtension).arg(AppSettings::missionFileExtension).arg(AppSettings::waypointsFileExtension).arg("txt") <<
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
               tr("All Files (*.*)");
    return filters;
}


QStringList PlanMasterController::saveNameFilters(void) const
{
    QStringList filters;

    filters << tr("Plan Files (*.%1)").arg(fileExtension()) << tr("All Files (*.*)");
    return filters;
}

void PlanMasterController::sendPlanToVehicle(Vehicle* vehicle, const QString& filename)
{
    // Use a transient PlanMasterController to accomplish this
    PlanMasterController* controller = new PlanMasterController();
582
    controller->startStaticActiveVehicle(vehicle, true /* deleteWhenSendCompleted */);
583
    controller->loadFromFile(filename);
584
    controller->sendToVehicle();
585
}
DonLakeFlyer's avatar
DonLakeFlyer committed
586 587 588

void PlanMasterController::_showPlanFromManagerVehicle(void)
{
589
    if (!_managerVehicle->initialPlanRequestComplete() && !syncInProgress()) {
590 591 592 593
        // Something went wrong with initial load. All controllers are idle, so just force it off
        _managerVehicle->forceInitialPlanRequestComplete();
    }

594
    // The crazy if structure is to handle the load propagating by itself through the system
DonLakeFlyer's avatar
DonLakeFlyer committed
595 596 597 598 599 600
    if (!_missionController.showPlanFromManagerVehicle()) {
        if (!_geoFenceController.showPlanFromManagerVehicle()) {
            _rallyPointController.showPlanFromManagerVehicle();
        }
    }
}
601 602 603 604 605 606 607

bool PlanMasterController::syncInProgress(void) const
{
    return _missionController.syncInProgress() ||
            _geoFenceController.syncInProgress() ||
            _rallyPointController.syncInProgress();
}
608 609 610 611 612 613 614

bool PlanMasterController::isEmpty(void) const
{
    return _missionController.isEmpty() &&
            _geoFenceController.isEmpty() &&
            _rallyPointController.isEmpty();
}
DonLakeFlyer's avatar
DonLakeFlyer committed
615 616 617 618 619 620

void PlanMasterController::_updatePlanCreatorsList(void)
{
    if (!_flyView) {
        if (!_planCreators) {
            _planCreators = new QmlObjectListModel(this);
621
            _planCreators->append(new BlankPlanCreator(this, this));
DonLakeFlyer's avatar
DonLakeFlyer committed
622 623 624 625 626 627 628
            _planCreators->append(new SurveyPlanCreator(this, this));
            _planCreators->append(new CorridorScanPlanCreator(this, this));
            emit planCreatorsChanged(_planCreators);
        }

        if (_managerVehicle->fixedWing()) {
            if (_planCreators->count() == 4) {
629
                _planCreators->removeAt(_planCreators->count() - 1);
DonLakeFlyer's avatar
DonLakeFlyer committed
630 631 632
            }
        } else {
            if (_planCreators->count() != 4) {
633
                _planCreators->append(new StructureScanPlanCreator(this, this));
DonLakeFlyer's avatar
DonLakeFlyer committed
634 635 636 637
            }
        }
    }
}
638 639 640 641 642 643 644 645 646

void PlanMasterController::_updateSupportsTerrain(void)
{
    bool supportsTerrain = _managerVehicle->capabilityBits() & MAV_PROTOCOL_CAPABILITY_TERRAIN;
    if (supportsTerrain != _supportsTerrain) {
        _supportsTerrain = supportsTerrain;
        emit supportsTerrainChanged(supportsTerrain);
    }
}