wimaBride converted to singelton and removed from qml, progess locking moded...

wimaBride converted to singelton and removed from qml, progess locking moded to wima planer, wima plan data mod.

qgroundcontrol.pro

@@ -419,6 +419,7 @@ FORMS += \
 
 HEADERS += \
     src/Wima/CircularSurvey.h \
+    src/Wima/GenericSingelton.h \
     src/Wima/Geometry/GenericCircle.h \
     src/Wima/RoutingThread.h \
     src/Wima/Snake/clipper/clipper.hpp \
@@ -464,6 +465,7 @@ HEADERS += \
     src/Wima/WaypointManager/Slicer.h \
     src/Wima/WaypointManager/Utils.h \
     src/Wima/WimaBridge.h \
+    src/Wima/call_once.h \
     src/api/QGCCorePlugin.h \
     src/api/QGCOptions.h \
     src/api/QGCSettings.h \
@@ -510,6 +512,7 @@ HEADERS += \
     src/comm/utilities.h
 SOURCES += \
     src/Wima/CircularSurvey.cc \
+    src/Wima/GenericSingelton.cpp \
     src/Wima/RoutingThread.cpp \
     src/Wima/Snake/clipper/clipper.cpp \
     src/Wima/Snake/snake.cpp \

src/FlightDisplay/FlightDisplayView.qml

@@ -117,10 +117,6 @@ QGCView {
 
     WimaController {
         id: wimaController
-        Component.onCompleted: {
-            wBridge.wimaController = Qt.binding(function() { return wimaController.thisPointer() })
-        }
-
         onForceUploadConfirm: {
             _guidedController.confirmAction(
                         _guidedController.actionForceUpload)

src/QGCApplication.cc

@@ -90,7 +90,6 @@
 #include "ViewWidgetController.h"
 #include "VisualMissionItem.h"
 #include "Wima/Snake/NemoInterface.h"
-#include "Wima/WimaBridge.h"
 #include "Wima/WimaController.h"
 #include "Wima/WimaPlaner.h"
 
@@ -520,7 +519,6 @@ void QGCApplication::_initCommon(void) {
   // Wima
   qmlRegisterType<WimaController>("Wima", 1, 0, "WimaController");
   qmlRegisterType<WimaPlaner>("Wima", 1, 0, "WimaPlaner");
-  qmlRegisterType<WimaBridge>("Wima", 1, 0, "WimaBridge");
   qmlRegisterType<NemoInterface>("Wima", 1, 0, "NemoInterface");
 
   // Register Qml Singletons

src/Wima/GenericSingelton.h

+#pragma once
+#include "call_once.h"
+#include <QScopedPointer>
+#include <QtGlobal>
+
+template <class T> class GenericSingelton {
+private:
+  typedef T *(*CreateInstanceFunction)();
+
+public:
+  static T *instance(CreateInstanceFunction create);
+
+private:
+  static void init();
+
+  GenericSingelton();
+  ~GenericSingelton();
+  Q_DISABLE_COPY(GenericSingelton)
+  static QBasicAtomicPointer<void> create;
+  static QBasicAtomicInt flag;
+  static QBasicAtomicPointer<void> tptr;
+  bool inited;
+};
+
+template <class T>
+T *GenericSingelton<T>::instance(CreateInstanceFunction create) {
+  GenericSingelton::create.store(reinterpret_cast<void *>(create));
+  qCallOnce(init, flag);
+  return (T *)tptr.load();
+}
+
+template <class T> void GenericSingelton<T>::init() {
+  static GenericSingelton singleton;
+  if (singleton.inited) {
+    CreateInstanceFunction createFunction =
+        (CreateInstanceFunction)GenericSingelton::create.load();
+    tptr.store(createFunction());
+  }
+}
+
+template <class T> GenericSingelton<T>::GenericSingelton() { inited = true; }
+
+template <class T> GenericSingelton<T>::~GenericSingelton() {
+  T *createdTptr = (T *)tptr.fetchAndStoreOrdered(nullptr);
+  if (createdTptr) {
+    delete createdTptr;
+  }
+  create.store(nullptr);
+}
+
+template <class T>
+QBasicAtomicPointer<void>
+    GenericSingelton<T>::create = Q_BASIC_ATOMIC_INITIALIZER(nullptr);
+template <class T>
+QBasicAtomicInt GenericSingelton<T>::flag =
+    Q_BASIC_ATOMIC_INITIALIZER(CallOnce::CO_Request);
+template <class T>
+QBasicAtomicPointer<void>
+    GenericSingelton<T>::tptr = Q_BASIC_ATOMIC_INITIALIZER(nullptr);

src/Wima/Geometry/WimaMeasurementAreaData.cc

@@ -38,7 +38,7 @@ void WimaMeasurementAreaData::setTileData(const TileData &d) {
 }
 
 void WimaMeasurementAreaData::setProgress(const QVector<int> &d) {
-  if (this->_progress != d) {
+  if (this->_progress != d && d.size() == this->_tileData.tiles.count()) {
     this->_progress = d;
     emit progressChanged();
   }

src/Wima/Snake/NemoInterface.cpp

@@ -48,7 +48,6 @@ public:
   void setAutoPublish(bool ap);
   void setHoldProgress(bool hp);
 
-  bool lockProgress();
   void publishTileData();
 
   NemoInterface::STATUS status();
@@ -77,7 +76,6 @@ private:
   QGeoCoordinate ENUOrigin;
   mutable std::shared_timed_mutex ENUOriginMutex;
   QNemoProgress qProgress;
-  QNemoProgress qProgressHolded;
   mutable std::shared_timed_mutex progressMutex;
   NemoInterface::STATUS status_;
   TimePoint nextTimeout;
@@ -88,7 +86,6 @@ private:
 
   // Internals
   std::atomic_bool running_;
-  std::atomic_bool lockProgress_;
   std::atomic_bool topicServiceSetupDone;
   ROSBridgePtr pRosBridge;
   QTimer loopTimer;
@@ -110,8 +107,7 @@ StatusMap statusMap{
 
 NemoInterface::Impl::Impl(NemoInterface *p)
     : status_(STATUS::NOT_CONNECTED), nextTimeout(TimePoint::max()),
-      running_(false), lockProgress_(false), topicServiceSetupDone(false),
-      parent(p) {
+      running_(false), topicServiceSetupDone(false), parent(p) {
 
   // ROS Bridge.
   WimaSettings *wimaSettings =
@@ -188,24 +184,6 @@ bool NemoInterface::Impl::hasTileData(const TileData &tileData) const {
   return this->tileData == tileData;
 }
 
-void NemoInterface::Impl::setHoldProgress(bool hp) {
-  if (this->lockProgress_ != hp) {
-    this->lockProgress_ = hp;
-    emit this->parent->lockProgressChanged();
-
-    if (!this->lockProgress_) {
-      UniqueLock lk(this->progressMutex);
-      if (this->qProgress != this->qProgressHolded) {
-        this->qProgressHolded = this->qProgress;
-        lk.unlock();
-        emit this->parent->progressChanged();
-      }
-    }
-  }
-}
-
-bool NemoInterface::Impl::lockProgress() { return this->lockProgress_.load(); }
-
 void NemoInterface::Impl::publishTileData() {
   std::lock(this->ENUOriginMutex, this->tilesENUMutex);
   UniqueLock lk1(this->ENUOriginMutex, std::adopt_lock);
@@ -225,7 +203,7 @@ NemoInterface::STATUS NemoInterface::Impl::status() {
 
 QVector<int> NemoInterface::Impl::progress() {
   SharedLock lk(this->progressMutex);
-  return this->qProgressHolded.progress();
+  return this->qProgress.progress();
 }
 
 bool NemoInterface::Impl::running() { return this->running_.load(); }
@@ -263,23 +241,17 @@ bool NemoInterface::Impl::doTopicServiceSetup() {
         UniqueLock lk3(this->ENUOriginMutex, std::adopt_lock);
 
         int requiredSize = this->tilesENU.polygons().size();
-        auto hold = this->lockProgress_.load();
         auto &progressMsg = this->qProgress;
         if (!nemo_msgs::progress::fromJson(*pDoc, progressMsg) ||
             progressMsg.progress().size() !=
                 requiredSize) { // Some error occured.
           progressMsg.progress().clear();
           qgcApp()->showMessage("Invalid progress message received.");
-        } else if (!hold) {
-          this->qProgressHolded = this->qProgress;
         }
+
         lk1.unlock();
         lk2.unlock();
         lk3.unlock();
-
-        if (!hold) {
-          emit this->parent->progressChanged();
-        }
       });
 
   // Subscribe /nemo/heartbeat.
@@ -452,10 +424,6 @@ bool NemoInterface::hasTileData(const TileData &tileData) const {
   return this->pImpl->hasTileData(tileData);
 }
 
-void NemoInterface::setHoldProgress(bool hp) {
-  this->pImpl->setHoldProgress(hp);
-}
-
 int NemoInterface::status() const { return integral(this->pImpl->status()); }
 
 NemoInterface::STATUS NemoInterface::statusEnum() const {
@@ -473,5 +441,3 @@ QString NemoInterface::editorQml() {
 }
 
 bool NemoInterface::running() { return this->pImpl->running(); }
-
-bool NemoInterface::lockProgress() { return this->pImpl->lockProgress(); }

src/Wima/Snake/NemoInterface.h

@@ -29,8 +29,6 @@ public:
   Q_PROPERTY(QVector<int> progress READ progress NOTIFY progressChanged)
   Q_PROPERTY(QString editorQml READ editorQml CONSTANT)
   Q_PROPERTY(bool running READ running NOTIFY runningChanged)
-  Q_PROPERTY(bool lockProgress READ lockProgress WRITE setHoldProgress NOTIFY
-                 lockProgressChanged)
 
   Q_INVOKABLE void start();
   Q_INVOKABLE void stop();
@@ -48,13 +46,11 @@ public:
   QVector<int> progress() const;
   QString editorQml();
   bool running();
-  bool lockProgress();
 
 signals:
   void statusChanged();
   void progressChanged();
   void runningChanged();
-  void lockProgressChanged();
 
 private:
   PImpl pImpl;

src/Wima/WimaBridge.cc

 #include "WimaBridge.h"
-#include "WimaController.h"
+#include "GenericSingelton.h"
 
 WimaBridge::WimaBridge(QObject *parent) : QObject(parent) {}
 
-WimaController *WimaBridge::wimaController() { return _wimaController; }
+WimaBridge *WimaBridge::createInstance() { return new WimaBridge(); }
 
-WimaPlaner *WimaBridge::wimaPlaner() { return _wimaPlaner; }
+WimaBridge::~WimaBridge() {}
 
-WimaBridge *WimaBridge::thisPointer() { return this; }
-
-void WimaBridge::setWimaController(WimaController *controller) {
-  if (_wimaController != controller) {
-    _wimaController = controller;
-
-    emit wimaControllerChanged(_wimaController);
-  }
+WimaBridge *WimaBridge::instance() {
+  return GenericSingelton<WimaBridge>::instance(WimaBridge::createInstance);
 }
 
-void WimaBridge::setWimaPlaner(WimaPlaner *planer) {
-  if (_wimaPlaner != planer) {
-    _wimaPlaner = planer;
+const WimaPlanData &WimaBridge::planData() const { return this->planData_; }
+
+const QVector<int> &WimaBridge::progress() const { return this->progress_; }
 
-    emit wimaPlanerChanged(_wimaPlaner);
+void WimaBridge::setProgress(const QVector<int> &p) {
+  if (this->progress_ != p) {
+    this->progress_ = p;
+    emit progressChanged();
   }
 }
 
-bool WimaBridge::setWimaPlanData(QSharedPointer<WimaPlanData> planData) {
-  if (_wimaController != nullptr) {
-    return _wimaController->setWimaPlanData(planData);
+void WimaBridge::setPlanData(const WimaPlanData &planData) {
+  if (this->planData_ != planData) {
+    this->planData_ = planData;
+    emit planDataChanged();
   }
-  return false;
 }

src/Wima/WimaBridge.h

@@ -11,34 +11,27 @@ class WimaPlaner;
 //!
 //! \brief The WimaBridge class
 //!
-//! A bridge establishing a link between WimaController and WimaPlaner
+//! A singelton bridge establishing a link between WimaController and WimaPlaner
 class WimaBridge : public QObject {
   Q_OBJECT
-public:
   WimaBridge(QObject *parent = nullptr);
   WimaBridge(WimaBridge &other) = delete;
+  static WimaBridge *createInstance();
 
-  Q_PROPERTY(WimaPlaner *wimaPlaner READ wimaPlaner WRITE setWimaPlaner NOTIFY
-                 wimaPlanerChanged)
-  Q_PROPERTY(WimaController *wimaController READ wimaController WRITE
-                 setWimaController NOTIFY wimaControllerChanged)
-
-  WimaController *wimaController();
-  WimaPlaner *wimaPlaner();
-
-  Q_INVOKABLE WimaBridge *thisPointer();
-
-  void setWimaController(WimaController *controller);
-  void setWimaPlaner(WimaPlaner *planer);
-
-signals:
-  void wimaControllerChanged(WimaController *controller);
-  void wimaPlanerChanged(WimaPlaner *planer);
+public:
+  ~WimaBridge();
+  static WimaBridge *instance();
+  const WimaPlanData &planData() const;
+  const QVector<int> &progress() const;
 
 public slots:
-  bool setWimaPlanData(QSharedPointer<WimaPlanData> planData);
+  void setPlanData(const WimaPlanData &planData);
+  void setProgress(const QVector<int> &p);
+signals:
+  void planDataChanged();
+  void progressChanged();
 
 private:
-  WimaController *_wimaController;
-  WimaPlaner *_wimaPlaner;
+  WimaPlanData planData_;
+  QVector<int> progress_;
 };

src/Wima/WimaController.cc

@@ -10,6 +10,8 @@
 #include "SettingsManager.h"
 #include "SimpleMissionItem.h"
 
+#include "WimaBridge.h"
+#include "WimaPlanData.h"
 #include "WimaSettings.h"
 
 #include "Snake/QNemoHeartbeat.h"
@@ -69,6 +71,12 @@ WimaController::WimaController(QObject *parent)
   connect(&_eventTimer, &QTimer::timeout, this,
           &WimaController::_eventTimerHandler);
   _eventTimer.start(EVENT_TIMER_INTERVAL);
+
+  // PlanData and Progress.
+  connect(WimaBridge::instance(), &WimaBridge::planDataChanged, this,
+          &WimaController::planDataChangedHandler);
+  connect(WimaBridge::instance(), &WimaBridge::progressChanged, this,
+          &WimaController::progressChangedHandler);
 }
 
 PlanMasterController *WimaController::masterController() {
@@ -214,7 +222,8 @@ bool WimaController::_calcShortestPath(const QGeoCoordinate &start,
   return retVal;
 }
 
-bool WimaController::setWimaPlanData(QSharedPointer<WimaPlanData> planData) {
+void WimaController::planDataChangedHandler() {
+
   // reset visual items
   _areas.clear();
   _measurementArea = WimaMeasurementAreaData();
@@ -228,8 +237,9 @@ bool WimaController::setWimaPlanData(QSharedPointer<WimaPlanData> planData) {
 
   _planDataValid = false;
 
+  auto planData = WimaBridge::instance()->planData();
   // extract list with WimaAreas
-  QList<const WimaAreaData *> areaList = planData->areaList();
+  QList<const WimaAreaData *> areaList = planData.areaList();
 
   int areaCounter = 0;
   const int numAreas = 4; // extract only numAreas Areas, if there are more
@@ -279,7 +289,7 @@ bool WimaController::setWimaPlanData(QSharedPointer<WimaPlanData> planData) {
 
   if (areaCounter != numAreas) {
     Q_ASSERT(false);
-    return false;
+    return;
   }
 
   emit visualItemsChanged();
@@ -288,7 +298,10 @@ bool WimaController::setWimaPlanData(QSharedPointer<WimaPlanData> planData) {
       _serviceArea.depot().latitude(), _serviceArea.depot().longitude(), 0));
 
   _planDataValid = true;
-  return true;
+}
+
+void WimaController::progressChangedHandler() {
+  _measurementArea.setProgress(WimaBridge::instance()->progress());
 }
 
 WimaController *WimaController::thisPointer() { return this; }

src/Wima/WimaController.h

@@ -10,8 +10,6 @@
 #include "Geometry/WimaMeasurementAreaData.h"
 #include "Geometry/WimaServiceAreaData.h"
 
-#include "WimaPlanData.h"
-
 #include "SettingsFact.h"
 
 #include "Geometry/GeoPoint3D.h"
@@ -69,7 +67,6 @@ public:
   // Property setters
   void setMasterController(PlanMasterController *masterController);
   void setMissionController(MissionController *missionController);
-  bool setWimaPlanData(QSharedPointer<WimaPlanData> planData);
 
   // Member Methodes
   Q_INVOKABLE WimaController *thisPointer();
@@ -107,7 +104,8 @@ signals:
   void forceUploadConfirm(void);
 
 private slots:
-
+  void planDataChangedHandler();
+  void progressChangedHandler();
   bool _calcShortestPath(const QGeoCoordinate &start,
                          const QGeoCoordinate &destination,
                          QVector<QGeoCoordinate> &path);

src/Wima/WimaPlanData.cc

@@ -31,9 +31,6 @@ WimaPlanData &WimaPlanData::operator=(const WimaPlanData &other) {
     }
   }
 
-  // copy mission items
-  _missionItems = other.missionItems();
-
   return *this;
 }
 
@@ -89,37 +86,25 @@ void WimaPlanData::append(const WimaMeasurementAreaData &areaData) {
   }
 }
 
-void WimaPlanData::setTransects(const QList<QList<QGeoCoordinate>> &transects) {
-  _transects = transects;
-}
-
-void WimaPlanData::append(const QList<MissionItem *> &missionItems) {
-  for (auto *item : missionItems) {
-    item->setParent(this);
-    _missionItems.append(item);
-  }
-}
-
 /*!
  * \fn void WimaPlanData::append(const WimaServiceAreaData &areaData)
  *
  * Clears all stored objects
  */
-void WimaPlanData::clear() {
-  _areaList.clear();
-  _missionItems.clear();
-}
+void WimaPlanData::clear() { _areaList.clear(); }
 
 const QList<const WimaAreaData *> &WimaPlanData::areaList() const {
   return _areaList;
 }
 
-const QList<QList<QGeoCoordinate>> &WimaPlanData::transects() const {
-  return _transects;
+bool WimaPlanData::operator==(const WimaPlanData &other) const {
+  return this->_joinedArea == other._joinedArea &&
+         this->_measurementArea == other._measurementArea &&
+         this->_corridor == other._corridor &&
+         this->_serviceArea == other._serviceArea;
 }
-
-const QList<MissionItem *> &WimaPlanData::missionItems() const {
-  return _missionItems;
+bool WimaPlanData::operator!=(const WimaPlanData &other) const {
+  return !(*this == other);
 }
 
 /*!

src/Wima/WimaPlanData.h

@@ -35,6 +35,9 @@ public:
   const QList<QList<QGeoCoordinate>> &transects() const;
   const QList<MissionItem *> &missionItems() const;
 
+  bool operator==(const WimaPlanData &other) const;
+  bool operator!=(const WimaPlanData &other) const;
+
 signals:
   void areaListChanged();
 
@@ -44,7 +47,4 @@ private:
   WimaCorridorData _corridor;
   WimaMeasurementAreaData _measurementArea;
   QList<const WimaAreaData *> _areaList;
-
-  QList<QList<QGeoCoordinate>> _transects;
-  QList<MissionItem *> _missionItems;
 };

src/Wima/WimaPlaner.cc

@@ -38,12 +38,12 @@ const char *WimaPlaner::missionItemsName = "MissionItems";
 
 WimaPlaner::WimaPlaner(QObject *parent)
     : QObject(parent), _masterController(nullptr), _missionController(nullptr),
-      _currentAreaIndex(-1), _wimaBridge(nullptr), _copyMAreaToSurvey(true),
-      _copySAreaToSurvey(true), _corridorChanged(true), _joinedArea(this),
-      _arrivalPathLength(0), _returnPathLength(0), _survey(nullptr),
-      _surveyChanged(true), _synchronized(false), _nemoInterface(this),
+      _currentAreaIndex(-1), _copyMAreaToSurvey(true), _copySAreaToSurvey(true),
+      _corridorChanged(true), _joinedArea(this), _arrivalPathLength(0),
+      _returnPathLength(0), _survey(nullptr), _surveyChanged(true),
+      _synchronized(false), _nemoInterface(this),
       _stateMachine(new StateMachine), _areasMonitored(false),
-      _missionControllerMonitored(false) {
+      _missionControllerMonitored(false), _progressLocked(false) {
 
   connect(this, &WimaPlaner::currentPolygonIndexChanged, this,
           &WimaPlaner::updatePolygonInteractivity);
@@ -112,8 +112,6 @@ QGeoCoordinate WimaPlaner::joinedAreaCenter() const {
   return _joinedArea.center();
 }
 
-WimaBridge *WimaPlaner::wimaBridge() { return _wimaBridge; }
-
 NemoInterface *WimaPlaner::nemoInterface() { return &_nemoInterface; }
 
 void WimaPlaner::setMasterController(PlanMasterController *masterC) {
@@ -141,10 +139,14 @@ void WimaPlaner::setCurrentPolygonIndex(int index) {
   }
 }
 
-void WimaPlaner::setWimaBridge(WimaBridge *bridge) {
-  if (bridge != nullptr) {
-    _wimaBridge = bridge;
-    emit wimaBridgeChanged();
+void WimaPlaner::setProgressLocked(bool l) {
+  if (this->_progressLocked != l) {
+    this->_progressLocked = l;
+    emit progressLockedChanged();
+    if (!this->_progressLocked) {
+      this->_measurementArea.setProgress(this->_nemoInterface.progress());
+      this->_update();
+    }
   }
 }
 
@@ -156,6 +158,8 @@ bool WimaPlaner::readyForSynchronization() {
   return this->_stateMachine->surveyReady();
 }
 
+bool WimaPlaner::progressLocked() { return this->_progressLocked; }
+
 WimaPlaner *WimaPlaner::thisPointer() { return this; }
 
 void WimaPlaner::removeArea(int index) {
@@ -557,8 +561,13 @@ void WimaPlaner::missionControllerMissionItemCountChangedHandler() {
 }
 
 void WimaPlaner::nemoInterfaceProgressChangedHandler() {
-  this->_measurementArea.setProgress(this->_nemoInterface.progress());
-  this->_update();
+  auto p = this->_nemoInterface.progress();
+  WimaBridge::instance()->setProgress(p);
+
+  if (!progressLocked()) {
+    this->_measurementArea.setProgress(p);
+    this->_update();
+  }
 }
 
 void WimaPlaner::saveToCurrent() { saveToFile(_currentFile); }
@@ -792,18 +801,14 @@ void WimaPlaner::updatePolygonInteractivity(int index) {
 }
 
 void WimaPlaner::synchronize() {
-  if (_wimaBridge != nullptr) {
-    if (readyForSynchronization()) {
-      auto planData = toPlanData();
-      if (planData) {
-        (void)_wimaBridge->setWimaPlanData(planData);
-        setSynchronized(true);
-      } else {
-        qCWarning(WimaPlanerLog) << "error creating plan data.";
-      }
+  if (readyForSynchronization()) {
+    WimaPlanData planData;
+    if (toPlanData(planData)) {
+      WimaBridge::instance()->setPlanData(planData);
+      setSynchronized(true);
+    } else {
+      qCWarning(WimaPlanerLog) << "error creating plan data.";
     }
-  } else {
-    qCWarning(WimaPlanerLog) << "no container assigned.";
   }
 }
 
@@ -940,27 +945,14 @@ void WimaPlaner::setInteractive() {
  *
  * \sa WimaController, WimaPlanData
  */
-QSharedPointer<WimaPlanData> WimaPlaner::toPlanData() {
-  QSharedPointer<WimaPlanData> planData(new WimaPlanData());
+bool WimaPlaner::toPlanData(WimaPlanData &planData) {
 
   // store areas
-  planData->append(WimaMeasurementAreaData(_measurementArea));
-  planData->append(WimaServiceAreaData(_serviceArea));
-  planData->append(WimaCorridorData(_corridor));
-  planData->append(WimaJoinedAreaData(_joinedArea));
-
-  // convert mission items to mavlink commands
-  if (_missionController && _missionController->visualItems()) {
-    int surveyIndex = _missionController->visualItems()->indexOf(_survey);
-    if (surveyIndex > 0) {
-      QList<MissionItem *> missionItems;
-      _survey->appendMissionItems(missionItems, nullptr);
-      planData->append(missionItems);
-      planData->setTransects(this->_survey->rawTransects());
-      return planData;
-    }
-  }
-  return QSharedPointer<WimaPlanData>();
+  planData.append(WimaMeasurementAreaData(_measurementArea));
+  planData.append(WimaServiceAreaData(_serviceArea));
+  planData.append(WimaCorridorData(_corridor));
+  planData.append(WimaJoinedAreaData(_joinedArea));
+  return true;
 }
 
 #ifndef NDEBUG

src/Wima/WimaPlaner.h

@@ -21,7 +21,6 @@
 
 class MissionController;
 class PlanMasterController;
-class WimaBridge;
 
 namespace wima_planer_detail {
 class StateMachine;
@@ -51,13 +50,13 @@ public:
   Q_PROPERTY(QStringList saveNameFilters READ saveNameFilters CONSTANT)
   Q_PROPERTY(QString fileExtension READ fileExtension CONSTANT)
   Q_PROPERTY(QGeoCoordinate joinedAreaCenter READ joinedAreaCenter CONSTANT)
-  Q_PROPERTY(WimaBridge *wimaBridge READ wimaBridge WRITE setWimaBridge NOTIFY
-                 wimaBridgeChanged)
   Q_PROPERTY(NemoInterface *nemoInterface READ nemoInterface CONSTANT)
   Q_PROPERTY(bool synchronized READ synchronized NOTIFY synchronizedChanged)
   Q_PROPERTY(bool needsUpdate READ needsUpdate NOTIFY needsUpdateChanged)
   Q_PROPERTY(bool readyForSynchronization READ readyForSynchronization NOTIFY
                  readyForSynchronizationChanged)
+  Q_PROPERTY(bool progressLocked READ progressLocked WRITE setProgressLocked
+                 NOTIFY progressLockedChanged)
 
   // Property accessors
   PlanMasterController *masterController(void);
@@ -69,11 +68,11 @@ public:
   QStringList saveNameFilters(void) const;
   QString fileExtension(void) const;
   QGeoCoordinate joinedAreaCenter(void) const;
-  WimaBridge *wimaBridge(void);
   NemoInterface *nemoInterface(void);
   bool synchronized();
   bool needsUpdate();
   bool readyForSynchronization();
+  bool progressLocked();
 
   // Property setters
   void setMasterController(PlanMasterController *masterController);
@@ -81,7 +80,7 @@ public:
   /// Sets the integer index pointing to the current polygon. Current polygon is
   /// set interactive.
   void setCurrentPolygonIndex(int index);
-  void setWimaBridge(WimaBridge *bridge);
+  void setProgressLocked(bool l);
 
   Q_INVOKABLE WimaPlaner *thisPointer();
   Q_INVOKABLE bool addMeasurementArea();
@@ -120,6 +119,7 @@ signals:
   void synchronizedChanged(void);
   void needsUpdateChanged(void);
   void readyForSynchronizationChanged(void);
+  void progressLockedChanged();
 
 private slots:
   void updatePolygonInteractivity(int index);
@@ -152,7 +152,7 @@ signals:
 
 private:
   // Member Functions
-  QSharedPointer<WimaPlanData> toPlanData();
+  bool toPlanData(WimaPlanData &planData);
   bool shortestPath(const QGeoCoordinate &start,
                     const QGeoCoordinate &destination,
                     QVector<QGeoCoordinate> &path);
@@ -169,8 +169,6 @@ private:
   MissionController *_missionController;
   int _currentAreaIndex;
   QString _currentFile;
-  // container for data exchange with WimaController
-  WimaBridge *_wimaBridge;
 
   bool _joinedAreaValid;
   WimaMeasurementArea _measurementArea;
@@ -205,4 +203,5 @@ private:
   QScopedPointer<wima_planer_detail::StateMachine> _stateMachine;
   bool _areasMonitored;
   bool _missionControllerMonitored;
+  bool _progressLocked;
 };

src/Wima/call_once.h

+#ifndef CALL_ONCE_H
+#define CALL_ONCE_H
+
+#include <QAtomicInt>
+#include <QMutex>
+#include <QThread>
+#include <QThreadStorage>
+#include <QWaitCondition>
+#include <QtGlobal>
+
+namespace CallOnce {
+enum ECallOnce { CO_Request, CO_InProgress, CO_Finished };
+
+Q_GLOBAL_STATIC(QThreadStorage<QAtomicInt *>, once_flag)
+} // namespace CallOnce
+
+template <class Function>
+inline static void qCallOnce(Function func, QBasicAtomicInt &flag) {
+  using namespace CallOnce;
+
+#if QT_VERSION < 0x050000
+  int protectFlag = flag.fetchAndStoreAcquire(flag);
+#elif QT_VERSION >= 0x050000
+  int protectFlag = flag.fetchAndStoreAcquire(flag.load());
+#endif
+
+  if (protectFlag == CO_Finished)
+    return;
+  if (protectFlag == CO_Request &&
+      flag.testAndSetRelaxed(protectFlag, CO_InProgress)) {
+    func();
+    flag.fetchAndStoreRelease(CO_Finished);
+  } else {
+    do {
+      QThread::yieldCurrentThread();
+    } while (!flag.testAndSetAcquire(CO_Finished, CO_Finished));
+  }
+}
+
+template <class Function> inline static void qCallOncePerThread(Function func) {
+  using namespace CallOnce;
+  if (!once_flag()->hasLocalData()) {
+    once_flag()->setLocalData(new QAtomicInt(CO_Request));
+    qCallOnce(func, *once_flag()->localData());
+  }
+}
+
+#endif // CALL_ONCE_H

src/WimaView/WimaToolBar.qml

@@ -327,17 +327,16 @@ Rectangle {
                 property var nemo: wimaPlaner ? wimaPlaner.nemoInterface : undefined
 
                 text:               qsTr("Lock Progress")
-                checked: nemo ? nemo.lockProgress : false
+                checked: wimaPlaner ? wimaPlaner.progressLocked : false
                 visible: enableCheckbox.checked
                 onCheckedChanged: {
-                    if (nemo){
+                    if (wimaPlaner){
                         if (checked){
-                            nemo.lockProgress = true
+                            wimaPlaner.progressLocked = true
                         } else {
-                            nemo.lockProgress = false
+                            wimaPlaner.progressLocked = false
                         }
-
-                        checked = Qt.binding(function(){return nemo.lockProgress})
+                        checked = Qt.binding(function(){return wimaPlaner.progressLocked})
                     }
                 }
                 Layout.minimumWidth:    _mediumValueWidth

src/WimaView/WimaView.qml

@@ -208,8 +208,6 @@ QGCView {
         Component.onCompleted: {
             wimaPlaner.masterController     = Qt.binding(function () { return masterController})
             wimaPlaner.missionController    = Qt.binding(function () { return masterController.missionController})
-            wimaPlaner.wimaBridge           = Qt.binding(function () { return wBridge.thisPointer()})
-            wBridge.wimaPlaner              = Qt.binding(function () { return wimaPlaner.thisPointer()})
         }
         function addComplexItem(complexItemName) {
             var coordinate = editorMap.center

src/ui/MainWindowInner.qml

@@ -174,11 +174,6 @@ Item {
         }
     }
 
-    // Wima Data Container
-    WimaBridge{
-        id: wimaBridge
-    }
-
     MessageDialog {
         id:                 unsavedMissionCloseDialog
         title:              qsTr("%1 close").arg(QGroundControl.appName)
@@ -386,7 +381,6 @@ Item {
         visible:            false
 
         property var planToolBar:        planToolBar
-        property var wBridge:            wimaBridge
     }
 
 
@@ -404,7 +398,6 @@ Item {
         visible:            false
 
         property var toolbar:               wimaToolBar
-        property var wBridge:               wimaBridge
     }
 
 
@@ -413,7 +406,6 @@ Item {
         anchors.fill:       parent
         visible:            true
 
-        property var wBridge:  wimaBridge
        //-------------------------------------------------------------------------
         //-- Loader helper for any child, no matter how deep can display an element
         //   on top of the video window.