loading almost finished

src/MeasurementComplexItem/AreaData.cc

@@ -13,14 +13,13 @@ QGC_LOGGING_CATEGORY(AreaDataLog, "AreaDataLog")
 
 const char *originKey = "Origin";
 const char *areaListKey = "AreaList";
-const char *initializedKey = "Initialized";
 
 AreaData::AreaData(QObject *parent) : QObject(parent) {}
 
 AreaData::~AreaData() {}
 
 AreaData::AreaData(const AreaData &other, QObject *parent)
-    : QObject(parent), _initialized(false), _showErrorMessages(true) {
+    : QObject(parent), _showErrorMessages(true) {
   *this = other;
 }
 
@@ -35,7 +34,6 @@ AreaData &AreaData::operator=(const AreaData &other) {
   }
 
   _origin = other._origin;
-  _initialized = other._initialized;
 
   return *this;
 }
@@ -130,11 +128,10 @@ bool AreaData::isCorrect() {
   //  qDebug() << ss.str().c_str();
   if (!bg::covered_by(measurementAreaENU, safeAreaENU)) {
     _processError(tr("Measurement Area not inside Safe Area. Please adjust "
-                     "the Measurement Area."));
+                     "the Measurement Area.\n"));
     return false;
   }
 
-  _initialized = true;
   return true;
 }
 
@@ -196,7 +193,6 @@ bool AreaData::initialize(const QGeoCoordinate &bottomLeft,
         safeArea->vertexCoordinate(0).longitude() * 0.5 +
             measurementArea->vertexCoordinate(0).longitude() * 0.5));
 
-    _initialized = true;
     return true;
   } else {
     qCWarning(AreaDataLog)
@@ -206,7 +202,12 @@ bool AreaData::initialize(const QGeoCoordinate &bottomLeft,
   }
 }
 
-bool AreaData::initialized() { return _initialized; }
+bool AreaData::initialized() {
+  auto measurementArea = getGeoArea<MeasurementArea *>(_areaList);
+  auto safeArea = getGeoArea<SafeArea *>(_areaList);
+  return measurementArea != nullptr && safeArea != nullptr &&
+         measurementArea->count() >= 3 && safeArea->count() >= 3;
+}
 
 void AreaData::intersection() {
   if (initialized() && _areasCorrect()) {
@@ -261,6 +262,12 @@ void AreaData::intersection() {
   }
 }
 
+MeasurementArea *AreaData::measurementArea() {
+  return getGeoArea<MeasurementArea *>(_areaList);
+}
+
+SafeArea *AreaData::safeArea() { return getGeoArea<SafeArea *>(_areaList); }
+
 bool AreaData::operator==(const AreaData &other) const {
   if (_areaList.count() == other._areaList.count()) {
     for (int i = 0; i < _areaList.count(); ++i) {
@@ -280,119 +287,93 @@ bool AreaData::operator!=(const AreaData &other) const {
 bool AreaData::load(const QJsonObject &obj, QString &errorString) {
   bool returnValue = true;
 
-  // load initialized.
-  {
-    QString e;
-    QList<JsonHelper::KeyValidateInfo> keyInfo = {
-        {initializedKey, QJsonValue::Bool, true},
-    };
-    if (JsonHelper::validateKeys(obj, keyInfo, e)) {
-      _initialized = obj[initializedKey].toBool();
-    } else {
-      returnValue = false;
-      errorString.append(e);
-      errorString.append("\n");
-    }
-  }
-
   // load areaList.
-  {
-    QString e;
-    QList<JsonHelper::KeyValidateInfo> keyInfo = {
-        {areaListKey, QJsonValue::Array, true},
-    };
-    if (JsonHelper::validateKeys(obj, keyInfo, e)) {
-      this->clear();
-      // iterate over json array
-      for (const auto valueRef : obj[areaListKey].toArray()) {
-        const auto jsonArea = valueRef.toObject();
-        // check if area type key is present
-        QList<JsonHelper::KeyValidateInfo> areaInfo = {
-            {GeoArea::areaTypeKey, QJsonValue::String, true},
-        };
-        if (!JsonHelper::validateKeys(jsonArea, areaInfo, e)) {
-          // load MeasurementArea
-          if (jsonArea[GeoArea::areaTypeKey].toString() ==
-              MeasurementArea::name) {
-            auto area = getGeoArea<MeasurementArea *>(_areaList);
-            if (area == nullptr) {
-              auto area = new MeasurementArea(this);
-              if (area->loadFromJson(jsonArea, e)) {
-                this->insert(area);
-              } else {
-                returnValue = false;
-                errorString.append(e);
-                errorString.append("\n");
-                area->deleteLater();
-              }
+  if (obj.contains(areaListKey) && obj[areaListKey].isArray()) {
+
+    this->clear();
+
+    // iterate over json array
+    for (const auto valueRef : obj[areaListKey].toArray()) {
+      const auto jsonArea = valueRef.toObject();
+
+      // check if area type key is present
+      if (jsonArea.contains(GeoArea::areaTypeKey) &&
+          jsonArea[GeoArea::areaTypeKey].isString()) {
+
+        // load MeasurementArea
+        if (jsonArea[GeoArea::areaTypeKey].toString() ==
+            MeasurementArea::name) {
+
+          auto area = getGeoArea<MeasurementArea *>(_areaList);
+
+          if (area == nullptr) {
+
+            auto area = new MeasurementArea(this);
+            QString e;
+            if (area->loadFromJson(jsonArea, e)) {
+              this->insert(area);
             } else {
               returnValue = false;
-              errorString.append(
-                  tr("Multiple Measurement Areas detected. Area was ignored."));
+              errorString.append(e);
+              errorString.append("\n");
+              area->deleteLater();
             }
+          } else {
+            returnValue = false;
+            errorString.append(
+                tr("Multiple Measurement Areas detected. Area was ignored."));
           }
-          // load SafeArea
-          else if (jsonArea[GeoArea::areaTypeKey].toString() ==
-                   SafeArea::name) {
-            auto area = getGeoArea<SafeArea *>(_areaList);
-            if (area == nullptr) {
-              auto area = new SafeArea(this);
-              if (area->loadFromJson(jsonArea, e)) {
-                this->insert(area);
-              } else {
-                returnValue = false;
-                errorString.append(e);
-                errorString.append("\n");
-                area->deleteLater();
-              }
+        }
+        // load SafeArea
+        else if (jsonArea[GeoArea::areaTypeKey].toString() == SafeArea::name) {
+
+          auto area = getGeoArea<SafeArea *>(_areaList);
+          if (area == nullptr) {
+
+            auto area = new SafeArea(this);
+            QString e;
+            if (area->loadFromJson(jsonArea, e)) {
+              this->insert(area);
             } else {
               returnValue = false;
-              errorString.append(
-                  tr("Multiple Safe Areas detected. Area was ignored."));
+              errorString.append(e);
+              errorString.append("\n");
+              area->deleteLater();
             }
-          }
-          // unknown area
-          else {
+          } else {
             returnValue = false;
-            errorString.append(tr("Unknown area type: ") +
-                               jsonArea[GeoArea::areaTypeKey].toString());
+            errorString.append(
+                tr("Multiple Safe Areas detected. Area was ignored."));
           }
         }
-        // GeoArea::areaTypeKey missing
+        // unknown area
         else {
           returnValue = false;
-          errorString.append(e);
-          errorString.append("\n");
+          errorString.append(tr("Unknown area type: ") +
+                             jsonArea[GeoArea::areaTypeKey].toString());
         }
+      } else {
+        // GeoArea::areaTypeKey missing
+        returnValue = false;
+        errorString.append(
+            "Area type key missing, not able to determine area type.\n");
       }
     }
+  } else {
     // AreaList missing
-    else {
-      returnValue = false;
-      errorString.append(e);
-      errorString.append("\n");
-    }
+    returnValue = false;
+    errorString.append("Not able to load areas.\n");
   }
 
   // load origin
-  {
+  if (obj.contains(originKey) && obj[originKey].isObject()) {
+    QGeoCoordinate origin;
     QString e;
-    QList<JsonHelper::KeyValidateInfo> keyInfo = {
-        {originKey, QJsonValue::Object, true},
-    };
-    if (JsonHelper::validateKeys(obj, keyInfo, e)) {
-      QGeoCoordinate origin;
-      if (JsonHelper::loadGeoCoordinate(obj[originKey], false, origin, e)) {
-        _origin = origin;
-      }
+    if (JsonHelper::loadGeoCoordinate(obj[originKey], false, origin, e)) {
+      _origin = origin;
     }
   }
 
-  // check if this is correct.
-  if (!this->isCorrect()) {
-    returnValue = false;
-  }
-
   return returnValue;
 }
 
@@ -402,7 +383,6 @@ bool AreaData::save(QJsonObject &obj) {
   QJsonValue jsonOrigin;
   JsonHelper::saveGeoCoordinate(_origin, false, jsonOrigin);
   temp[originKey] = jsonOrigin;
-  temp[initializedKey] = _initialized;
 
   QJsonArray jsonAreaList;
   for (int i = 0; i < _areaList.count(); ++i) {

src/MeasurementComplexItem/AreaData.h

@@ -71,6 +71,9 @@ public:
   Q_INVOKABLE bool initialized();
   Q_INVOKABLE void intersection();
 
+  Q_INVOKABLE MeasurementArea *measurementArea();
+  Q_INVOKABLE SafeArea *safeArea();
+
   bool operator==(const AreaData &other) const;
   bool operator!=(const AreaData &other) const;
 
@@ -98,7 +101,6 @@ private:
 
   QGeoCoordinate _origin;
   QmlObjectListModel _areaList;
-  bool _initialized;
   QString _errorString;
   bool _showErrorMessages;
 };

src/MeasurementComplexItem/CircularGenerator.cpp

@@ -21,8 +21,6 @@ template <> inline auto get<1>(const IntPoint &p) { return p.Y; }
 namespace routing {
 
 namespace {
-const QString generatorType = "CircularGenerator";
-
 GeneratorBase *creator(QObject *parent) {
   return new CircularGenerator(parent);
 }
@@ -33,8 +31,6 @@ const char *minLengthKey = "MinLength";
 const char *referenceKey = "ReferencePoint";
 } // namespace
 
-REGISTER_GENERATOR(generatorType, creator)
-
 bool circularTransects(const snake::FPoint &reference,
                        const snake::FPolygon &polygon,
                        const std::vector<snake::FPolygon> &tiles,
@@ -42,9 +38,20 @@ bool circularTransects(const snake::FPoint &reference,
                        snake::Length minLength, snake::Transects &transects);
 
 const char *CircularGenerator::settingsGroup = "CircularGenerator";
+const char *CircularGenerator::typeString = "CircularGenerator";
+
+REGISTER_GENERATOR(CircularGenerator::typeString, creator)
 
 CircularGenerator::CircularGenerator(QObject *parent)
-    : CircularGenerator(nullptr, parent) {}
+    : GeneratorBase(parent),
+      _metaDataMap(FactMetaData::createMapFromJsonFile(
+          QStringLiteral(":/json/CircularGenerator.SettingsGroup.json"), this)),
+      _distance(settingsGroup, _metaDataMap[distanceKey]),
+      _deltaAlpha(settingsGroup, _metaDataMap[deltaAlphaKey]),
+      _minLength(settingsGroup, _metaDataMap[minLengthKey]),
+      _measurementArea(nullptr) {
+  init();
+}
 
 CircularGenerator::CircularGenerator(GeneratorBase::Data d, QObject *parent)
     : GeneratorBase(d, parent),
@@ -54,28 +61,20 @@ CircularGenerator::CircularGenerator(GeneratorBase::Data d, QObject *parent)
       _deltaAlpha(settingsGroup, _metaDataMap[deltaAlphaKey]),
       _minLength(settingsGroup, _metaDataMap[minLengthKey]),
       _measurementArea(nullptr) {
-  connect(this->distance(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->deltaAlpha(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->minLength(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this, &CircularGenerator::referenceChanged, this,
-          &GeneratorBase::generatorChanged);
-  setName(tr("Circular Generator"));
+  init();
 }
 
-QString CircularGenerator::editorQml() {
+QString CircularGenerator::editorQml() const {
   return QStringLiteral("CircularGeneratorEditor.qml");
 }
 
-QString CircularGenerator::mapVisualQml() {
+QString CircularGenerator::mapVisualQml() const {
   return QStringLiteral("CircularGeneratorMapVisual.qml");
 }
 
-QString CircularGenerator::abbreviation() { return tr("C. Gen."); }
+QString CircularGenerator::abbreviation() const { return tr("C. Gen."); }
 
-QString CircularGenerator::type() { return generatorType; }
+QString CircularGenerator::type() const { return typeString; }
 
 bool CircularGenerator::get(Generator &generator) {
   if (this->_d) {
@@ -327,19 +326,21 @@ void CircularGenerator::resetReferenceIfInvalid() {
 }
 
 void CircularGenerator::resetReference() {
-  auto measurementArea =
-      getGeoArea<const MeasurementArea *>(*this->_d->areaList());
+  if (this->_d != nullptr) {
+    auto measurementArea =
+        getGeoArea<const MeasurementArea *>(*this->_d->areaList());
 
-  if (measurementArea != nullptr) {
-    if (measurementArea->center().isValid()) {
-      setReference(measurementArea->center());
+    if (measurementArea != nullptr) {
+      if (measurementArea->center().isValid()) {
+        setReference(measurementArea->center());
+      } else {
+        qCWarning(CircularGeneratorLog)
+            << "measurement area center" << measurementArea->center();
+      }
     } else {
-      qCWarning(CircularGeneratorLog)
-          << "measurement area center" << measurementArea->center();
+      qCDebug(CircularGeneratorLog)
+          << "resetReference(): measurement area == nullptr";
     }
-  } else {
-    qCDebug(CircularGeneratorLog)
-        << "resetReference(): measurement area == nullptr";
   }
 }
 
@@ -350,8 +351,34 @@ Fact *CircularGenerator::deltaAlpha() { return &_deltaAlpha; }
 Fact *CircularGenerator::minLength() { return &_minLength; }
 
 void CircularGenerator::onAreaListChanged() {
-  auto *measurementArea = getGeoArea<MeasurementArea *>(*this->_d->areaList());
-  setMeasurementArea(measurementArea);
+  if (this->_d != nullptr) {
+    auto *measurementArea =
+        getGeoArea<MeasurementArea *>(*this->_d->areaList());
+    setMeasurementArea(measurementArea);
+  }
+}
+
+void CircularGenerator::onDataChanged() {
+  if (this->_d != nullptr) {
+    connect(this->_d, &AreaData::areaListChanged, this,
+            &CircularGenerator::onAreaListChanged);
+    onAreaListChanged();
+  }
+}
+
+void CircularGenerator::init() {
+  connect(this->distance(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this->deltaAlpha(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this->minLength(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this, &CircularGenerator::referenceChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this, &CircularGenerator::dataChanged, this,
+          &CircularGenerator::onDataChanged);
+  onDataChanged();
+  setName(tr("Circular Generator"));
 }
 
 void CircularGenerator::setMeasurementArea(MeasurementArea *area) {

src/MeasurementComplexItem/CircularGenerator.h

@@ -20,11 +20,11 @@ public:
   Q_PROPERTY(Fact *deltaAlpha READ deltaAlpha CONSTANT)
   Q_PROPERTY(Fact *minLength READ minLength CONSTANT)
 
-  virtual QString editorQml() override;
-  virtual QString mapVisualQml() override;
+  virtual QString editorQml() const override;
+  virtual QString mapVisualQml() const override;
 
-  virtual QString abbreviation() override;
-  virtual QString type() override;
+  virtual QString abbreviation() const override;
+  virtual QString type() const override;
 
   virtual bool get(Generator &generator) override;
 
@@ -47,6 +47,7 @@ public:
   virtual bool load(const QJsonObject &obj, QString &guiErrorMessage) override;
 
   static const char *settingsGroup;
+  static const char *typeString;
 
 signals:
   void referenceChanged();
@@ -55,8 +56,12 @@ public slots:
   Q_INVOKABLE void resetReferenceIfInvalid();
   Q_INVOKABLE void resetReference();
 
-private:
+private slots:
   void onAreaListChanged();
+  void onDataChanged();
+
+private:
+  void init();
   void setMeasurementArea(MeasurementArea *area);
 
   QGeoCoordinate _reference;

src/MeasurementComplexItem/GeneratorBase.cc

@@ -11,20 +11,18 @@ GeneratorBase::GeneratorBase(QObject *parent)
     : GeneratorBase(nullptr, parent) {}
 
 GeneratorBase::GeneratorBase(GeneratorBase::Data d, QObject *parent)
-    : QObject(parent), _d(d) {
-  establishConnections();
-}
+    : QObject(parent), _d(d) {}
 
 GeneratorBase::~GeneratorBase() {}
 
 bool GeneratorBase::save(QJsonObject &obj) const {
-  obj[typeKey] = type();
-  obj[name] = name();
+  obj[typeKey] = this->type();
+  obj[nameKey] = this->name();
   return true;
 }
 
 bool GeneratorBase::load(const QJsonObject &obj, QString &errorString) {
-  if (obj.contains[nameKey] && obj[nameKey].isString()) {
+  if (obj.contains(nameKey) && obj[nameKey].isString()) {
     setName(obj[nameKey].toString());
     return true;
   } else {
@@ -46,18 +44,12 @@ void GeneratorBase::setName(const QString &name) {
 GeneratorBase::Data GeneratorBase::data() const { return _d; }
 
 void GeneratorBase::setData(Data d) {
-  if (d != _d && d != nullptr) {
-    deleteConnections();
+  if (d != _d) {
     _d = d;
-    establishConnections();
     emit dataChanged();
   }
 }
 
-void GeneratorBase::establishConnections() {}
-
-void GeneratorBase::deleteConnections() {}
-
 GeneratorFactory::GeneratorFactory() {}
 
 GeneratorFactory *GeneratorFactory::createInstance() {
@@ -112,14 +104,14 @@ GeneratorBase *GeneratorFactory::create(const QJsonObject &jsonGenerator,
         return nullptr;
       }
     } else {
-      errorMessage.append(QObject::tr("Not able to create generator of type") +
-                          " " +
-                          jsonGenerator[GeneratorBase::typeKey].toString());
+      errorMessage.append(
+          QObject::tr("Not able to create generator of type.\n") + " " +
+          jsonGenerator[GeneratorBase::typeKey].toString());
       return nullptr;
     }
   } else {
     errorMessage.append(QObject::tr(
-        "Not able to load Generator. Impossible to determine type."));
+        "Not able to load Generator. Impossible to determine type.\n"));
     return nullptr;
   }
 }

src/MeasurementComplexItem/GeneratorBase.h

@@ -53,8 +53,6 @@ signals:
   void nameChanged();
 
 protected:
-  virtual void establishConnections();
-  virtual void deleteConnections();
   Data _d;
   QString _name;
 
@@ -87,7 +85,7 @@ private:
 
 #define REGISTER_GENERATOR(type, creator)                                      \
   namespace {                                                                  \
-  auto registered_##type =                                                     \
+  auto registered =                                                            \
       GeneratorFactory::instance() -> registerGenerator(type, creator);        \
   }
 } // namespace routing

src/MeasurementComplexItem/LinearGenerator.cpp

@@ -14,8 +14,6 @@
 namespace routing {
 
 namespace {
-const QString generatorType = "LinearGenerator";
-
 GeneratorBase *creator(QObject *parent) { return new LinearGenerator(parent); }
 
 const char *distanceKey = "TransectDistance";
@@ -23,7 +21,6 @@ const char *alphaKey = "Alpha";
 const char *minLengthKey = "MinLength";
 } // namespace
 
-REGISTER_GENERATOR(generatorType, creator)
 QGC_LOGGING_CATEGORY(LinearGeneratorLog, "LinearGeneratorLog")
 
 bool linearTransects(const snake::FPolygon &polygon,
@@ -32,9 +29,20 @@ bool linearTransects(const snake::FPolygon &polygon,
                      snake::Length minLength, snake::Transects &transects);
 
 const char *LinearGenerator::settingsGroup = "LinearGenerator";
+const char *LinearGenerator::typeString = "LinearGenerator";
+
+REGISTER_GENERATOR("LinearGenerator", creator)
 
 LinearGenerator::LinearGenerator(QObject *parent)
-    : LinearGenerator(nullptr, parent) {}
+    : GeneratorBase(nullptr, parent),
+      _metaDataMap(FactMetaData::createMapFromJsonFile(
+          QStringLiteral(":/json/LinearGenerator.SettingsGroup.json"), this)),
+      _distance(settingsGroup, _metaDataMap[distanceKey]),
+      _alpha(settingsGroup, _metaDataMap[alphaKey]),
+      _minLength(settingsGroup, _metaDataMap[minLengthKey]),
+      _measurementArea(nullptr) {
+  init();
+}
 
 LinearGenerator::LinearGenerator(GeneratorBase::Data d, QObject *parent)
     : GeneratorBase(d, parent),
@@ -43,30 +51,24 @@ LinearGenerator::LinearGenerator(GeneratorBase::Data d, QObject *parent)
       _distance(settingsGroup, _metaDataMap[distanceKey]),
       _alpha(settingsGroup, _metaDataMap[alphaKey]),
       _minLength(settingsGroup, _metaDataMap[minLengthKey]),
-      _measurementArea(nullptr), _safeArea(nullptr) {
-  connect(this->distance(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->alpha(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->minLength(), &Fact::rawValueChanged, this,
-          &GeneratorBase::generatorChanged);
-  connect(this->_d, &AreaData::areaListChanged, this,
-          &LinearGenerator::onAreaListChanged);
-  setName(tr("Linear Generator"));
+      _measurementArea(nullptr) {
+  init();
 }
 
-QString LinearGenerator::editorQml() {
+QString LinearGenerator::editorQml() const {
   return QStringLiteral("LinearGeneratorEditor.qml");
 }
 
-QString LinearGenerator::mapVisualQml() { return QStringLiteral(""); }
+QString LinearGenerator::mapVisualQml() const { return QStringLiteral(""); }
 
-QString LinearGenerator::abbreviation() { return QStringLiteral("L. Gen."); }
+QString LinearGenerator::abbreviation() const {
+  return QStringLiteral("L. Gen.");
+}
 
-QString LinearGenerator::type() { return generatorType; }
+QString LinearGenerator::type() const { return typeString; }
 
 bool LinearGenerator::get(Generator &generator) {
-  if (_d) {
+  if (_d != nullptr) {
     if (this->_d->isCorrect()) {
       // Prepare data.
       auto origin = this->_d->origin();
@@ -268,9 +270,33 @@ Fact *LinearGenerator::alpha() { return &_alpha; }
 
 Fact *LinearGenerator::minLength() { return &_minLength; }
 
+void LinearGenerator::init() {
+  connect(this->distance(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this->alpha(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this->minLength(), &Fact::rawValueChanged, this,
+          &GeneratorBase::generatorChanged);
+  connect(this, &LinearGenerator::dataChanged, this,
+          &LinearGenerator::onDataChanged);
+  onDataChanged();
+  setName(tr("Linear Generator"));
+}
+
 void LinearGenerator::onAreaListChanged() {
-  auto *measurementArea = getGeoArea<MeasurementArea *>(*this->_d->areaList());
-  setMeasurementArea(measurementArea);
+  if (this->_d != nullptr) {
+    auto *measurementArea =
+        getGeoArea<MeasurementArea *>(*this->_d->areaList());
+    setMeasurementArea(measurementArea);
+  }
+}
+
+void LinearGenerator::onDataChanged() {
+  if (this->_d != nullptr) {
+    connect(this->_d, &AreaData::areaListChanged, this,
+            &LinearGenerator::onAreaListChanged);
+    onAreaListChanged();
+  }
 }
 
 void LinearGenerator::setMeasurementArea(MeasurementArea *area) {

src/MeasurementComplexItem/LinearGenerator.h

@@ -19,11 +19,11 @@ public:
   Q_PROPERTY(Fact *alpha READ alpha CONSTANT)
   Q_PROPERTY(Fact *minLength READ minLength CONSTANT)
 
-  virtual QString editorQml() override;
-  virtual QString mapVisualQml() override;
+  virtual QString editorQml() const override;
+  virtual QString mapVisualQml() const override;
 
-  virtual QString abbreviation() override;
-  virtual QString type() override;
+  virtual QString abbreviation() const override;
+  virtual QString type() const override;
 
   virtual bool get(Generator &generator) override;
 
@@ -43,9 +43,14 @@ public:
   Fact *minLength();
 
   static const char *settingsGroup;
+  static const char *typeString;
 
-private:
+private slots:
   void onAreaListChanged();
+  void onDataChanged();
+
+private:
+  void init();
   void setMeasurementArea(MeasurementArea *area);
 
   QMap<QString, FactMetaData *> _metaDataMap;

src/MeasurementComplexItem/MeasurementComplexItem.h

@@ -123,7 +123,9 @@ public:
   //! editingStart() if it is invalid. Triggers a route update.
   //!
   //! \param doUpdate No route update will be triggered if false, route update
-  //! will eventually be triggered if true. \return Returns true if a route
+  //! will eventually be triggered if true.
+  //!
+  //!  \return Returns true if a route
   //! update was triggered, false either.
   //!
   Q_INVOKABLE bool stopEditing(bool doUpdate = true);
@@ -145,7 +147,7 @@ public:
   QStringList variantNames() const;
 
   bool calculating() const;
-  bool editing() const;
+  bool editing() const; // set to true on creation
   bool idle() const;
   bool followTerrain() const;
 

src/MeasurementComplexItem/qml/AreaDataEditor.qml

@@ -23,11 +23,8 @@ GridLayout {
 
     Component.onCompleted: {
         console.assert(missionItem !== undefined, "please set the missionItem property")
-        checkedChangedHandler()
     }
 
-    onCheckedChanged: checkedChangedHandler()
-
     ExclusiveGroup{id:areaGroup}
 
     Repeater{
@@ -115,13 +112,5 @@ GridLayout {
             _areaData.intersection()
         }
     }
-
-    function checkedChangedHandler(){
-        if (_root.checked){
-            missionItem.startEditing()
-        } else {
-            missionItem.stopEditing()
-        }
-    }
 }
 

src/MeasurementComplexItem/qml/MeasurementItemEditor.qml

@@ -65,7 +65,7 @@ Rectangle {
                 Layout.fillWidth: true
                 Layout.columnSpan: 2
                 onClicked:{
-                    areaDataEditor.checked = true
+                        _missionItem.startEditing()
                 }
             }
 
@@ -75,7 +75,7 @@ Rectangle {
                 visible: areaDataEditor.visible
                 onClicked: {
                     if (_areaData.isCorrect()){
-                        parameterEditor.checked = true
+                        _missionItem.stopEditing()
                     }
                 }
             }
@@ -86,32 +86,18 @@ Rectangle {
                 Layout.fillWidth: true
                 onClicked:{
                     missionItem.abortEditing()
-                    parameterEditor.checked = true
                 }
             }
 
         } // editorSelector
 
-        ExclusiveGroup { id:editorGroup}
-
         MCI.ParameterEditor{
             id:parameterEditor
 
             missionItem: _root._missionItem
             availableWidth: mainColumn.width
+            checked: !_missionItem.editing
             visible: checked
-
-            property ExclusiveGroup group: editorGroup
-
-            onGroupChanged: {
-                if (group){
-                    group.bindCheckable(parameterEditor)
-                }
-            }
-
-            Component.onCompleted: {
-                checked = false
-            }
         }
 
         MCI.AreaDataEditor{
@@ -119,19 +105,8 @@ Rectangle {
 
             missionItem: _root._missionItem
             availableWidth: mainColumn.width
+            checked: _missionItem.editing
             visible: checked
-
-            property ExclusiveGroup group: editorGroup
-
-            onGroupChanged: {
-                if (group){
-                    group.bindCheckable(areaDataEditor)
-                }
-            }
-
-            Component.onCompleted: {
-                checked = true
-            }
         }
 
     } // main Column

src/MeasurementComplexItem/qml/MeasurementItemMapVisual.qml

@@ -55,9 +55,12 @@ Item {
 
     Component.onCompleted: {
         console.assert(map != undefined, "please set the map property")
-        var bbox = boundingBox()
-        _missionItem.areaData.initialize(bbox[0], bbox[1])
-//        _addEntryCoordinate()
+
+        if (!_missionItem.areaData.initialized()){
+            var bbox = boundingBox()
+            _missionItem.areaData.initialize(bbox[0], bbox[1])
+        }
+        //        _addEntryCoordinate()
 //        _addExitCoordinate()
         _addTransects()
         _addGeneratorVisuals()
@@ -174,7 +177,7 @@ Item {
 
     // Generator visuals
     function _addGeneratorVisuals(){
-        if (_generator.mapVisualQml && !_generatorObject) {
+        if (_generator && _generator.mapVisualQml && !_generatorObject) {
             var component = Qt.createComponent(_generator.mapVisualQml)
             if (component.status === Component.Error) {
                 console.log("Error loading Qml: ",

src/MeasurementComplexItem/qml/ParameterEditor.qml

@@ -187,7 +187,7 @@ ColumnLayout {
     } // indicator column
 
     function _addGeneratorEditor(){
-        if (_generator.editorQml && !_generatorEditor) {
+        if (_generator && _generator.editorQml && !_generatorEditor) {
             var component = Qt.createComponent(_generator.editorQml)
             if (component.status === Component.Error) {
                 console.log("Error loading Qml: ",