diff --git a/autotests/courseresource/test_courseresource.cpp b/autotests/courseresource/test_courseresource.cpp
index 88676f2..76fba2d 100644
--- a/autotests/courseresource/test_courseresource.cpp
+++ b/autotests/courseresource/test_courseresource.cpp
@@ -1,192 +1,192 @@
 /*
  *  Copyright 2013  Andreas Cord-Landwehr <cordlandwehr@kde.org>
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License as
  *  published by the Free Software Foundation; either version 2 of
  *  the License or (at your option) version 3 or any later version
  *  accepted by the membership of KDE e.V. (or its successor approved
  *  by the membership of KDE e.V.), which shall act as a proxy
  *  defined in Section 14 of version 3 of the license.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "test_courseresource.h"
 #include "resourcerepositorystub.h"
 #include "core/language.h"
 #include "core/unit.h"
 #include "core/phrase.h"
 #include "core/resources/languageresource.h"
 #include "core/resources/courseresource.h"
 
 #include <QTest>
 #include <QDebug>
 #include <QTemporaryFile>
 #include <QSignalSpy>
 #include <QIODevice>
 #include <QFile>
 #include <QXmlSchema>
 #include <QXmlSchemaValidator>
 #include <QDomDocument>
 
 TestCourseResource::TestCourseResource()
 {
 }
 
 void TestCourseResource::init()
 {
 }
 
 void TestCourseResource::cleanup()
 {
 }
 
 void TestCourseResource::courseSchemeValidationTest()
 {
     QUrl schemeFile = QUrl::fromLocalFile(":/artikulate/schemes/course.xsd");
     QXmlSchema courseSchema;
     QVERIFY(courseSchema.load(schemeFile));
     QVERIFY(courseSchema.isValid());
 }
 
 void TestCourseResource::loadCourseResource()
 {
     Language language;
     language.setId("de");
     ResourceRepositoryStub repository({&language});
     const QString courseDirectory = "data/courses/de/";
     const QString courseFile = courseDirectory + "de.xml";
 
     CourseResource course(QUrl::fromLocalFile(courseFile), &repository);
     QCOMPARE(course.file().toLocalFile(), courseFile);
     QCOMPARE(course.id(), "de");
     QCOMPARE(course.foreignId(), "artikulate-basic");
     QCOMPARE(course.title(), "Artikulate Deutsch");
     QCOMPARE(course.description(), "Ein Kurs in (hoch-)deutscher Aussprache.");
     QVERIFY(course.language() != nullptr);
     QCOMPARE(course.language()->id(), "de");
     QCOMPARE(course.unitList().count(), 1);
 
     const auto unit = course.unitList().first();
     QVERIFY(unit != nullptr);
     QCOMPARE(unit->id(), "1");
     QCOMPARE(unit->title(), QStringLiteral("Auf der Straße"));
     QCOMPARE(unit->foreignId(), "{dd60f04a-eb37-44b7-9787-67aaf7d3578d}");
 
     QCOMPARE(unit->phraseList().count(), 3);
     // note: this test takes the silent assumption that phrases are added to the list in same
     //   order as they are defined in the file. This assumption should be made explicit or dropped
     const auto firstPhrase = unit->phraseList().first();
     QVERIFY(firstPhrase != nullptr);
     QCOMPARE(firstPhrase->id(), "1");
     QCOMPARE(firstPhrase->foreignId(), "{3a4c1926-60d7-44c6-80d1-03165a641c75}");
     QCOMPARE(firstPhrase->text(), "Guten Tag.");
     QCOMPARE(firstPhrase->soundFileUrl(), courseDirectory + "de_01.ogg");
     QCOMPARE(firstPhrase->type(), Phrase::Type::Sentence);
     QVERIFY(firstPhrase->phonemes().isEmpty());
 }
 
 void TestCourseResource::unitAddAndRemoveHandling()
 {
     // boilerplate
     Language language;
     language.setId("de");
     ResourceRepositoryStub repository({&language});
     const QString courseDirectory = "data/courses/de/";
     const QString courseFile = courseDirectory + "de.xml";
     CourseResource course(QUrl::fromLocalFile(courseFile), &repository);
 
     // begin of test
-    Unit unit;
-    unit.setId("testunit");
+    Unit *unit = new Unit;
+    unit->setId("testunit");
     const int initialUnitNumber = course.unitList().count();
     QCOMPARE(initialUnitNumber, 1);
     QSignalSpy spyAboutToBeAdded(&course, SIGNAL(unitAboutToBeAdded(Unit*, int)));
     QSignalSpy spyAdded(&course, SIGNAL(unitAdded()));
     QCOMPARE(spyAboutToBeAdded.count(), 0);
     QCOMPARE(spyAdded.count(), 0);
-    course.addUnit(&unit);
+    course.addUnit(unit);
     QCOMPARE(course.unitList().count(), initialUnitNumber + 1);
     QCOMPARE(spyAboutToBeAdded.count(), 1);
     QCOMPARE(spyAdded.count(), 1);
 }
 
 void TestCourseResource::coursePropertyChanges()
 {
     // boilerplate
     Language language;
     language.setId("de");
     ResourceRepositoryStub repository({&language});
     const QString courseDirectory = "data/courses/de/";
     const QString courseFile = courseDirectory + "de.xml";
     CourseResource course(QUrl::fromLocalFile(courseFile), &repository);
 
     // id
     {
         const QString value = "newId";
         QSignalSpy spy(&course, SIGNAL(idChanged()));
         QCOMPARE(spy.count(), 0);
         course.setId(value);
         QCOMPARE(course.id(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // foreign id
     {
         const QString value = "newForeignId";
         QSignalSpy spy(&course, SIGNAL(foreignIdChanged()));
         QCOMPARE(spy.count(), 0);
         course.setForeignId(value);
         QCOMPARE(course.foreignId(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // title
     {
         const QString value = "newTitle";
         QSignalSpy spy(&course, SIGNAL(titleChanged()));
         QCOMPARE(spy.count(), 0);
         course.setTitle(value);
         QCOMPARE(course.title(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // title
     {
         const QString value = "newI18nTitle";
         QSignalSpy spy(&course, SIGNAL(i18nTitleChanged()));
         QCOMPARE(spy.count(), 0);
         course.setI18nTitle(value);
         QCOMPARE(course.i18nTitle(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // description
     {
         const QString value = "newDescription";
         QSignalSpy spy(&course, SIGNAL(descriptionChanged()));
         QCOMPARE(spy.count(), 0);
         course.setDescription(value);
         QCOMPARE(course.description(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // language
     {
         Language testLanguage;
         QSignalSpy spy(&course, SIGNAL(languageChanged()));
         QCOMPARE(spy.count(), 0);
         course.setLanguage(&testLanguage);
         QCOMPARE(course.language(), &testLanguage);
         QCOMPARE(spy.count(), 1);
     }
 }
 
 QTEST_GUILESS_MAIN(TestCourseResource)
diff --git a/src/core/contributorrepository.cpp b/src/core/contributorrepository.cpp
index 951b133..8b6788f 100644
--- a/src/core/contributorrepository.cpp
+++ b/src/core/contributorrepository.cpp
@@ -1,489 +1,489 @@
 /*
  *  Copyright 2013-2019  Andreas Cord-Landwehr <cordlandwehr@kde.org>
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License as
  *  published by the Free Software Foundation; either version 2 of
  *  the License or (at your option) version 3 or any later version
  *  accepted by the membership of KDE e.V. (or its successor approved
  *  by the membership of KDE e.V.), which shall act as a proxy
  *  defined in Section 14 of version 3 of the license.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "contributorrepository.h"
 #include "artikulate_debug.h"
 #include "language.h"
 #include "unit.h"
 #include "phrase.h"
 #include "phoneme.h"
 #include "phonemegroup.h"
 #include "resources/languageresource.h"
 #include "resources/editablecourseresource.h"
 #include "resources/skeletonresource.h"
 #include "liblearnerprofile/src/profilemanager.h"
 #include "liblearnerprofile/src/learninggoal.h"
 
 #include <QFile>
 #include <QUuid>
 #include <QDir>
 #include <QDirIterator>
 #include <QUrl>
 #include <QStandardPaths>
 
-ContributorRepository::ContributorRepository(QObject *parent)
+ContributorRepository::ContributorRepository()
     : IEditableRepository()
 {
     loadLanguageResources();
 }
 
 ContributorRepository::~ContributorRepository()
 {
     for (auto skeleton : m_skeletonResources) {
         skeleton->deleteLater();
     }
     m_skeletonResources.clear();
     for (auto language : m_languageResources) {
         language->deleteLater();
     }
 }
 
 void ContributorRepository::loadLanguageResources()
 {
     // load language resources
     // all other resources are only loaded on demand
     QDir dir(":/artikulate/languages/");
     dir.setFilter(QDir::Files | QDir::NoSymLinks);
     QFileInfoList list = dir.entryInfoList();
     for (int i = 0; i < list.size(); ++i) {
         QFileInfo fileInfo = list.at(i);
         if (fileInfo.completeSuffix() != QLatin1String("xml")) {
             continue;
         }
         addLanguage(QUrl::fromLocalFile(fileInfo.absoluteFilePath()));
     }
 }
 
 void ContributorRepository::sync()
 {
 //    QMap< QString, QList< CourseResource* > >::iterator iter;
 //    for (iter = m_courseResources.begin(); iter != m_courseResources.end(); ++iter) {
 //        foreach (auto const &courseRes, iter.value()) {
 //            courseRes->sync();
 //        }
 //    }
 //    foreach (auto const &courseRes, m_skeletonResources) {
 //        courseRes->sync();
 //    }
 }
 
 bool ContributorRepository::modified() const
 {
     for (auto iter = m_courses.constBegin(); iter != m_courses.constEnd(); ++iter) {
         for (auto *course : iter.value()) {
             if (course->isModified()) {
                 return true;
             }
         }
     }
     foreach (auto const &courseRes, m_skeletonResources) {
         if (courseRes->isModified()) {
             return true;
         }
     }
     return false;
 }
 
 void ContributorRepository::addLanguage(const QUrl &languageFile)
 {
     if (m_loadedResources.contains(languageFile.toLocalFile())) {
         return;
     }
 
     LanguageResource *resource = new LanguageResource(languageFile);
 
     emit languageResourceAboutToBeAdded(resource, m_languageResources.count());
     m_languageResources.append(resource);
     m_loadedResources.append(languageFile.toLocalFile());
     m_courses.insert(resource->identifier(), QList<EditableCourseResource*>());
     emit languageResourceAdded();
 }
 
 QString ContributorRepository::storageLocation() const
 {
     return m_storageLocation;
 }
 
 void ContributorRepository::setStorageLocation(const QString &path)
 {
     m_storageLocation = path;
 }
 
 QList< LanguageResource* > ContributorRepository::languageResources() const
 {
     return m_languageResources;
 }
 
 QVector<Language *> ContributorRepository::languages() const
 {
     QVector<Language *> languages;
     for (auto resourse : m_languageResources) {
         languages.append(resourse->language());
     }
     return languages;
 }
 
 Language * ContributorRepository::language(int index) const
 {
     Q_ASSERT(index >= 0 && index < m_languageResources.count());
     return m_languageResources.at(index)->language();
 }
 
 Language * ContributorRepository::language(LearnerProfile::LearningGoal *learningGoal) const
 {
     if (!learningGoal) {
         return nullptr;
     }
     if (learningGoal->category() != LearnerProfile::LearningGoal::Language) {
         qCritical() << "Cannot translate non-language learning goal to language";
         return nullptr;
     }
     foreach (LanguageResource *resource, m_languageResources) {
         if (resource->identifier() == learningGoal->identifier()) {
             return resource->language();
         }
     }
     qCritical() << "No language registered with identifier " << learningGoal->identifier() << ": aborting";
     return nullptr;
 }
 
 QList<EditableCourseResource *> ContributorRepository::courseResources(Language *language)
 {
     if (!language) {
         QList<EditableCourseResource *> courses;
         for (auto iter = m_courses.constBegin(); iter != m_courses.constEnd(); ++iter) {
             courses.append(iter.value());
         }
         return courses;
     }
     // return empty list if no course available for language
     if (!m_courses.contains(language->id())) {
         return QList< EditableCourseResource* >();
     }
     return m_courses[language->id()];
 }
 
 QVector<ICourse *> ContributorRepository::courses() const
 {
     QVector<ICourse *> courses;
     for (const auto &courseList : m_courses) {
         for (const auto &course : courseList) {
             courses.append(course);
         }
     }
     return courses;
 }
 
 QVector<IEditableCourse *> ContributorRepository::editableCourses() const
 {
     QVector<IEditableCourse *> courses;
     for (const auto &courseList : m_courses) {
         for (const auto &course : courseList) {
             courses.append(course);
         }
     }
     return courses;
 }
 
 QVector<ICourse *> ContributorRepository::courses(Language *language) const
 {
     if (language == nullptr) {
         return courses();
     }
 
     QVector<ICourse *> courses;
     if (m_courses.contains(language->id())) {
         for (const auto &course : m_courses[language->id()]) {
             courses.append(course);
         }
     }
     return courses;
 }
 
 IEditableCourse * ContributorRepository::editableCourse(Language *language, int index) const
 {
     Q_ASSERT(m_courses.contains(language->id()));
     Q_ASSERT(index >= 0 && index < m_courses[language->id()].count());
 
     return m_courses[language->id()].at(index);
 }
 
 void ContributorRepository::reloadCourseOrSkeleton(ICourse *courseOrSkeleton)
 {
     if (!courseOrSkeleton) {
         qCritical() << "Cannot reload non-existing course";
         return;
     }
     if (!courseOrSkeleton->file().isValid()) {
         qCritical() << "Cannot reload temporary file, aborting.";
         return;
     }
 
     // figure out if this is a course or a skeleton
     if (courseOrSkeleton->language()) { // only course files have a language
         //TODO better add a check if this is contained in the course list
         // to catch possible errors
         QUrl file = courseOrSkeleton->file();
         m_loadedResources.removeOne(courseOrSkeleton->file().toLocalFile());
         removeCourse(courseOrSkeleton);
         addCourse(file);
     } else {
         for (SkeletonResource *resource : m_skeletonResources) {
             if (resource->id() == courseOrSkeleton->id()) {
                 // TODO no reload available
                 return;
             }
         }
     }
 }
 
 void ContributorRepository::reloadCourses()
 {
     // register skeleton resources
     QDir skeletonDirectory = QDir(storageLocation());
 
     skeletonDirectory.setFilter(QDir::Files | QDir::Hidden);
     if (!skeletonDirectory.cd(QStringLiteral("skeletons"))) {
         qCritical() << "There is no subdirectory \"skeletons\" in directory " << skeletonDirectory.path()
             << " cannot load skeletons.";
     } else {
         // read skeletons
         QFileInfoList list = skeletonDirectory.entryInfoList();
         for (int i = 0; i < list.size(); ++i) {
             QFileInfo fileInfo = list.at(i);
             addSkeleton(QUrl::fromLocalFile(fileInfo.absoluteFilePath()));
         }
     }
 
     // register contributor course files
     QDir courseDirectory(storageLocation());
     if (!courseDirectory.cd(QStringLiteral("courses"))) {
         qCritical() << "There is no subdirectory \"courses\" in directory " << courseDirectory.path()
             << " cannot load courses.";
     } else {
         // find courses
         courseDirectory.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
         QFileInfoList courseDirList = courseDirectory.entryInfoList();
 
         // traverse all course directories
         for (const QFileInfo &info : courseDirList) {
             QDir courseDir = QDir(info.absoluteFilePath());
             courseDir.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
             QFileInfoList courseLangDirList = courseDir.entryInfoList();
 
             // traverse all language directories for each course
             for (const QFileInfo &langInfo : courseLangDirList) {
                 QDir courseLangDir = QDir(langInfo.absoluteFilePath());
                 courseLangDir.setFilter(QDir::Files);
                 QStringList nameFilters;
                 nameFilters.append(QStringLiteral("*.xml"));
                 QFileInfoList courses = courseLangDir.entryInfoList(nameFilters);
 
                 // find and add course files
                 for (const QFileInfo &courseInfo : courses) {
                     addCourse(QUrl::fromLocalFile(courseInfo.filePath()));
                 }
             }
         }
     }
     //TODO this signal should only be emitted when repository was added/removed
     // yet the call to this method is very seldom and emitting it too often is not that harmful
     emit repositoryChanged();
 }
 
 void ContributorRepository::updateCourseFromSkeleton(IEditableCourse *course)
 {
     //TODO implement status information that are shown at mainwindow
     if (course->foreignId().isEmpty())  {
         qCritical() << "No skeleton ID specified, aborting update.";
         return;
     }
     ICourse *skeleton = nullptr;
     for (const auto &iter : m_skeletonResources) {
         if (iter->id() == course->foreignId()) {
             skeleton = iter;
             break;
         }
     }
     if (!skeleton)  {
         qCritical() << "Could not find skeleton with id " << course->foreignId() << ", aborting update.";
         return;
     }
 
     // update now
     for (Unit *unitSkeleton : skeleton->unitList()) {
         // import unit if not exists
         Unit *currentUnit = nullptr;
         bool found = false;
         for (Unit *unit : course->unitList()) {
             if (unit->foreignId() == unitSkeleton->id()) {
                 found = true;
                 currentUnit = unit;
                 break;
             }
         }
         if (found == false) {
             currentUnit = new Unit(course);
             currentUnit->setId(QUuid::createUuid().toString());
             currentUnit->setTitle(unitSkeleton->title());
             currentUnit->setForeignId(unitSkeleton->id());
             currentUnit->setCourse(course);
             course->addUnit(currentUnit);
         }
 
         // update phrases
         for (Phrase *phraseSkeleton : unitSkeleton->phraseList()) {
             bool found = false;
             for (Phrase *phrase : currentUnit->phraseList()) {
                 if (phrase->foreignId() == phraseSkeleton->id()) {
                     if (phrase->i18nText() != phraseSkeleton->text()) {
                         phrase->setEditState(Phrase::Unknown);
                         phrase->seti18nText(phraseSkeleton->text());
                     }
                     found = true;
                     break;
                 }
             }
             if (found == false) {
                 Phrase *newPhrase = new Phrase(course);
                 newPhrase->setForeignId(phraseSkeleton->id());
                 newPhrase->setId(QUuid::createUuid().toString());
                 newPhrase->setText(phraseSkeleton->text());
                 newPhrase->seti18nText(phraseSkeleton->text());
                 newPhrase->setType(phraseSkeleton->type());
                 newPhrase->setUnit(currentUnit);
                 currentUnit->addPhrase(newPhrase);
             }
         }
     }
     // FIXME deassociate removed phrases
     qCDebug(ARTIKULATE_LOG) << "Update performed!";
 }
 
 EditableCourseResource * ContributorRepository::addCourse(const QUrl &courseFile)
 {
     EditableCourseResource *resource = new EditableCourseResource(courseFile, this);
     if (resource->language() == nullptr) {
         delete resource;
         qCritical() << "Could not load course, language unknown:" << courseFile.toLocalFile();
         return nullptr;
     }
 
     // skip already loaded resources
     if (m_loadedResources.contains(courseFile.toLocalFile())) {
         delete resource;
         return nullptr;
     }
     m_loadedResources.append(courseFile.toLocalFile());
     addCourseResource(resource);
     emit languageCoursesChanged();
     return resource;
 }
 
 void ContributorRepository::addCourseResource(EditableCourseResource *resource)
 {
     Q_ASSERT(m_courses.contains(resource->language()->id()));
 
     if (!m_courses.contains(resource->language()->id())) {
         m_courses.insert(resource->language()->id(), QList<EditableCourseResource*>());
     }
     emit courseAboutToBeAdded(resource, m_courses[resource->language()->id()].count());
     m_courses[resource->language()->id()].append(resource);
     emit courseAdded();
 }
 
 void ContributorRepository::removeCourse(ICourse *course)
 {
     for (int index = 0; index < m_courses[course->language()->id()].length(); ++index) {
         if (m_courses[course->language()->id()].at(index) == course) {
             emit courseAboutToBeRemoved(index);
             m_courses[course->language()->id()].removeAt(index);
             emit courseRemoved();
             course->deleteLater();
             return;
         }
     }
 }
 
 EditableCourseResource * ContributorRepository::createCourse(Language *language, SkeletonResource *skeleton)
 {
     // set path
     QString path = QStringLiteral("%1/%2/%3/%4/%4.xml")
         .arg(storageLocation(),
              QStringLiteral("courses"),
              skeleton->id(),
              language->id());
 
     EditableCourseResource * course = new EditableCourseResource(QUrl::fromLocalFile(path), this);
 
     Q_ASSERT(course);
     course->setId(QUuid::createUuid().toString());
     course->setTitle(skeleton->title());
     course->setDescription(skeleton->description());
     course->setFile(QUrl::fromLocalFile(path));
     course->setLanguage(language);
 
     // set skeleton
     course->setForeignId(skeleton->id());
 
     addCourseResource(course);
 
     return course;
 }
 
 void ContributorRepository::addSkeleton(const QUrl &file)
 {
     SkeletonResource *resource = new SkeletonResource(file, this);
     addSkeletonResource(resource);
 }
 
 void ContributorRepository::addSkeletonResource(SkeletonResource *resource)
 {
     // skip already loaded resources
     if (m_loadedResources.contains(resource->file().toLocalFile())) {
         return;
     }
     m_loadedResources.append(resource->file().toLocalFile());
     emit skeletonAboutToBeAdded(resource, m_skeletonResources.count());
     m_skeletonResources.append(resource);
     emit skeletonAdded();
 }
 
 void ContributorRepository::removeSkeleton(SkeletonResource *skeleton)
 {
     for (int index = 0; index < m_skeletonResources.length(); ++index) {
         if (m_skeletonResources.at(index)->id() == skeleton->id()) {
             emit skeletonAboutToBeRemoved(index, index);
             m_skeletonResources.removeAt(index);
             emit skeletonRemoved();
             skeleton->deleteLater();
             return;
         }
     }
 }
 
 QVector<IEditableCourse *> ContributorRepository::skeletons() const
 {
     QVector<IEditableCourse *> skeletonList;
     for (const auto &skeleton : m_skeletonResources) {
         skeletonList.append(skeleton);
     }
     return skeletonList;
 }
diff --git a/src/core/contributorrepository.h b/src/core/contributorrepository.h
index 6675af7..43c55e0 100644
--- a/src/core/contributorrepository.h
+++ b/src/core/contributorrepository.h
@@ -1,211 +1,211 @@
 /*
  *  Copyright 2013-2019  Andreas Cord-Landwehr <cordlandwehr@kde.org>
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU General Public License as
  *  published by the Free Software Foundation; either version 2 of
  *  the License or (at your option) version 3 or any later version
  *  accepted by the membership of KDE e.V. (or its successor approved
  *  by the membership of KDE e.V.), which shall act as a proxy
  *  defined in Section 14 of version 3 of the license.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef CONTRIBUTORREPOSITORY_H
 #define CONTRIBUTORREPOSITORY_H
 
 #include "artikulatecore_export.h"
 #include "ieditablerepository.h"
 #include <QObject>
 #include <QMap>
 #include <QHash>
 #include <QVector>
 #include <QStringList>
 
 #include "liblearnerprofile/src/learninggoal.h"
 
 class SkeletonResource;
 class EditableCourseResource;
 class LanguageResource;
 class Language;
 class ICourse;
 class QUrl;
 
 /**
  * @class ContributorRepository
  * This class handles the resources of a contributor.
  */
 class ARTIKULATECORE_EXPORT ContributorRepository : public IEditableRepository
 {
     Q_OBJECT
     Q_INTERFACES(IResourceRepository)
     Q_INTERFACES(IEditableRepository)
 
     Q_PROPERTY(QString repositoryUrl READ storageLocation NOTIFY repositoryChanged)
 
 public:
-    explicit ContributorRepository(QObject *parent = nullptr);
+    explicit ContributorRepository();
     ~ContributorRepository() override;
 
     /**
      * save all changes to course resources
      */
     void sync();
 
     /**
      * \return \c true if any course or skeleton is modified, otherwise \c false
      */
     bool modified() const;
 
     /**
      * \return path to working repository, if one is set
      */
     QString storageLocation() const override;
 
     /**
      * Set path to central storage location
      * \param path the path to the storage location directory
      */
     void setStorageLocation(const QString &path);
 
     /**
      * \return list of all available language specifications
      */
     Q_DECL_DEPRECATED QList<LanguageResource *> languageResources() const;
 
     QVector<Language *> languages() const override;
 
     /**
      * \return language by \p index
      */
     Q_INVOKABLE Language * language(int index) const;
 
     /**
      * \return language by \p learningGoal
      */
     Q_INVOKABLE Language * language(LearnerProfile::LearningGoal* learningGoal) const;
 
     QVector<ICourse *> courses() const override;
     QVector<IEditableCourse *> editableCourses() const override;
     QVector<ICourse *> courses(Language *language) const override;
 
     /**
      * \return list of all loaded courses for language \p language
      */
     QList<EditableCourseResource *> courseResources(Language *language);
 
     Q_INVOKABLE IEditableCourse * editableCourse(Language *language, int index) const override;
 
     /**
      * Reset the file for this course or skeleton.
      *
      * \param course the course to be reloaded
      */
     Q_INVOKABLE void reloadCourseOrSkeleton(ICourse *course);
 
     /**
      * @brief Implementation of course resource reloading
      */
     void reloadCourses() override;
 
     void updateCourseFromSkeleton(IEditableCourse *course) override;
 
     /**
      * Add language to resource manager by parsing the given language specification file.
      *
      * \param languageFile is the local XML file containing the language
      */
     void addLanguage(const QUrl &languageFile);
 
     /**
      * Adds course to resource manager by parsing the given course specification file.
      *
      * \param courseFile is the local XML file containing the course
      * \return true if loaded successfully, otherwise false
      */
     EditableCourseResource * addCourse(const QUrl &courseFile);
 
     /**
      * Adds course to resource manager. If the course's language is not registered, the language
      * is registered by this method.
      *
      * \param resource the course resource to add to resource manager
      */
     void addCourseResource(EditableCourseResource *resource);
 
     /**
      * Remove course from resource manager. If the course is modified its changes are NOT
      * written. For writing changes, the Course::sync() method must be called directly.
      *
      * \param course is the course to be removed
      */
     void removeCourse(ICourse *course);
 
     /**
      * Create new course for \p language and derived from \p skeleton.
      *
      * \return created course
      */
     Q_INVOKABLE EditableCourseResource * createCourse(Language *language, SkeletonResource *skeleton);
 
     /**
      * Adds skeleton resource to resource manager
      *
      * \param resource the skeleton resource to add to resource manager
      */
     void addSkeleton(const QUrl &skeletonFile);
 
     /**
      * Adds skeleton resource to resource manager
      *
      * \param resource the skeleton resource to add to resource manager
      */
     void addSkeletonResource(SkeletonResource *resource);
 
     /**
      * Remove skeleton from resource manager. If the skeleton is modified its changes are NOT
      * written. For writing changes, the Skeleton::sync() method must be called directly.
      *
      * \param skeleton is the skeleton to be removed
      */
     void removeSkeleton(SkeletonResource *skeleton);
 
     QVector<IEditableCourse *> skeletons() const override;
 
 Q_SIGNALS:
     void languageResourceAdded();
     void languageResourceAboutToBeAdded(LanguageResource*,int);
     void languageResourceRemoved();
     void languageResourceAboutToBeRemoved(int);
     void repositoryChanged();
     void courseAdded() override;
     void courseAboutToBeAdded(ICourse*,int) override;
     void courseAboutToBeRemoved(int) override;
     void courseRemoved() override;
     void skeletonAdded();
     void skeletonAboutToBeAdded(ICourse*,int);
     void skeletonRemoved();
     void skeletonAboutToBeRemoved(int,int);
     void languageCoursesChanged();
 
 private:
     /**
      * This method loads all language files that are provided in the standard directories
      * for this application.
      */
     void loadLanguageResources();
     QString m_storageLocation;
     QList<LanguageResource *> m_languageResources;
     QMap<QString, QList<EditableCourseResource *> > m_courses; //!> (language-id, course-resource)
     QVector<SkeletonResource *> m_skeletonResources;
     QStringList m_loadedResources;
 };
 
 #endif