diff --git a/src/core/resources/courseparser.cpp b/src/core/resources/courseparser.cpp
index 18cedcb..4921c89 100644
--- a/src/core/resources/courseparser.cpp
+++ b/src/core/resources/courseparser.cpp
@@ -1,414 +1,389 @@
 /*
  *  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 "courseparser.h"
 #include "core/icourse.h"
 #include "core/language.h"
 #include "core/unit.h"
 #include "core/phrase.h"
 #include "core/phoneme.h"
 #include "artikulate_debug.h"
 
 #include <QDomDocument>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QXmlSchema>
 #include <QXmlStreamReader>
 #include <QXmlSchemaValidator>
 #include <KTar>
 
 
 QXmlSchema CourseParser::loadXmlSchema(const QString &schemeName)
 {
     QString relPath = QStringLiteral(":/artikulate/schemes/%1.xsd").arg(schemeName);
     QUrl file = QUrl::fromLocalFile(relPath);
 
     QXmlSchema schema;
     if (file.isEmpty() || schema.load(file) == false) {
         qCWarning(ARTIKULATE_PARSER()) << "Schema at file " << file.toLocalFile() << " is invalid.";
     }
     return schema;
 }
 
 QDomDocument CourseParser::loadDomDocument(const QUrl &path, const QXmlSchema &schema)
 {
     QDomDocument document;
     QXmlSchemaValidator validator(schema);
     if (!validator.validate(path)) {
         qCWarning(ARTIKULATE_PARSER()) << "Schema is not valid, aborting loading of XML document:" << path.toLocalFile();
         return document;
     }
 
     QString errorMsg;
     QFile file(path.toLocalFile());
     if (file.open(QIODevice::ReadOnly)) {
         if (!document.setContent(&file, &errorMsg)) {
             qCWarning(ARTIKULATE_PARSER()) << errorMsg;
         }
     } else {
         qCWarning(ARTIKULATE_PARSER()) << "Could not open XML document " << path.toLocalFile() << " for reading, aborting.";
     }
     return document;
 }
 
 std::vector<std::unique_ptr<Unit>> CourseParser::parseUnits(const QUrl &path)
 {
     std::vector<std::unique_ptr<Unit>> units;
 
     QFileInfo info(path.toLocalFile());
     if (!info.exists()) {
         qCCritical(ARTIKULATE_PARSER()()) << "No course file available at location" << path.toLocalFile();
         return units;
     }
 
     QXmlStreamReader xml;
     QFile file(path.toLocalFile());
     if (file.open(QIODevice::ReadOnly)) {
         xml.setDevice(&file);
         xml.readNextStartElement();
 
         while (!xml.atEnd() && !xml.hasError()) {
             bool elementOk{ false };
             QXmlStreamReader::TokenType token = xml.readNext();
 
             if (token == QXmlStreamReader::StartDocument) {
                 continue;
             }
             if (token == QXmlStreamReader::StartElement) {
                 if (xml.name() == "units") {
                     continue;
                 } else if (xml.name() == "unit") {
-                    auto unit = parseUnit(xml, elementOk);
+                    auto unit = parseUnit(xml, path, elementOk);
                     if (elementOk) {
                         units.push_back(std::move(unit));
                     }
                 }
             }
         }
         if (xml.hasError()) {
             qCCritical(ARTIKULATE_PARSER()) << "Error occurred when reading Course XML file:" << path.toLocalFile();
         }
     } else {
         qCCritical(ARTIKULATE_PARSER()) << "Could not open course file" << path.toLocalFile();
     }
     xml.clear();
     file.close();
 
     return units;
 }
 
-std::unique_ptr<Unit> CourseParser::parseUnit(QXmlStreamReader &xml, bool &ok)
+std::unique_ptr<Unit> CourseParser::parseUnit(QXmlStreamReader &xml, const QUrl &path, bool &ok)
 {
     std::unique_ptr<Unit> unit(new Unit);
     ok = true;
 
     if (xml.tokenType() != QXmlStreamReader::StartElement
         && xml.name() == "unit") {
         qCWarning(ARTIKULATE_PARSER()) << "Expected to parse 'unit' element, aborting here";
         return unit;
     }
 
     xml.readNext();
     while (!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == "unit")) {
         if (xml.tokenType() == QXmlStreamReader::StartElement) {
             bool elementOk{ false };
             if (xml.name() == "id") {
                 unit->setId(parseElement(xml, elementOk));
                 ok &= elementOk;
+            }  else if (xml.name() == "foreignId") {
+                unit->setForeignId(parseElement(xml, elementOk));
+                ok &= elementOk;
             } else if (xml.name() == "title") {
                 unit->setTitle(parseElement(xml, elementOk));
                 ok &= elementOk;
             } else if (xml.name() == "phrases") {
                 // nothing to do
             }
             else if (xml.name() == "phrase") {
-                auto phrase = parsePhrase(xml, elementOk);
+                auto phrase = parsePhrase(xml, path, elementOk);
                 if (elementOk) {
                     unit->addPhrase(phrase);
                 }
                 ok &= elementOk;
             } else {
                 qCWarning(ARTIKULATE_PARSER()) << "Skipping unknown token" << xml.name();
             }
         }
         xml.readNext();
     }
     if (!ok) {
         qCWarning(ARTIKULATE_PARSER()) << "Errors occured while parsing unit" << unit->title() << unit->id();
     }
     return unit;
 }
 
-Phrase * CourseParser::parsePhrase(QXmlStreamReader &xml, bool &ok)
+Phrase * CourseParser::parsePhrase(QXmlStreamReader &xml, const QUrl &path, bool &ok)
 {
     Phrase * phrase = new Phrase(nullptr);
     ok = true;
 
     if (xml.tokenType() != QXmlStreamReader::StartElement
         && xml.name() == "phrase") {
         qCWarning(ARTIKULATE_PARSER()) << "Expected to parse 'phrase' element, aborting here";
         ok = false;
         return phrase;
     }
 
     xml.readNext();
     while (!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == "phrase")) {
         if (xml.tokenType() == QXmlStreamReader::StartElement) {
             bool elementOk{ false };
             if (xml.name() == "id") {
                 phrase->setId(parseElement(xml, elementOk));
                 ok &= elementOk;
+            } else if (xml.name() == "foreignId") {
+                phrase->setForeignId(parseElement(xml, elementOk));
+                ok &= elementOk;
             } else if (xml.name() == "text") {
                 phrase->setText(parseElement(xml, elementOk));
                 ok &= elementOk;
+            } else if (xml.name() == "i18nText") {
+                phrase->seti18nText(parseElement(xml, elementOk));
+                ok &= elementOk;
+            } else if (xml.name() == "soundFile") {
+                phrase->setSound(QUrl::fromLocalFile(
+                        path.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path()
+                        + '/' + parseElement(xml, elementOk)));
+                ok &= elementOk;
             } else if (xml.name() == "type") {
                 const QString type = parseElement(xml, elementOk);
                 if (type == "word") {
                     phrase->setType(Phrase::Word);
                 } else if (type == "expression") {
                     phrase->setType(Phrase::Expression);
                 } else if (type == "sentence") {
                     phrase->setType(Phrase::Sentence);
                 } else if (type == "paragraph") {
                     phrase->setType(Phrase::Paragraph);
                 }
                 ok &= elementOk;
+            } else if (xml.name() == "editState") {
+                const QString type = parseElement(xml, elementOk);
+                if (type == "translated") {
+                    phrase->setEditState(Phrase::EditState::Translated);
+                } else if (type == "completed") {
+                    phrase->setEditState(Phrase::EditState::Completed);
+                } else if (type == "unknown") {
+                    phrase->setEditState(Phrase::EditState::Completed);
+                }
+                ok &= elementOk;
             } else {
                 qCWarning(ARTIKULATE_PARSER()) << "Skipping unknown token" << xml.name();
             }
         }
         xml.readNext();
     }
     if (!ok) {
         qCWarning(ARTIKULATE_PARSER()) << "Errors occured while parsing phrase" << phrase->text() << phrase->id();
     }
     return phrase;
 }
 
 QString CourseParser::parseElement(QXmlStreamReader& xml, bool &ok)
 {
     ok = true;
     if (xml.tokenType() != QXmlStreamReader::StartElement) {
         qCCritical(ARTIKULATE_PARSER()) << "Parsing element that does not start with a start element";
         ok = false;
         return QString();
     }
 
     QString elementName = xml.name().toString();
     xml.readNext();
 
 //    qCDebug(ARTIKULATE_PARSER()) << "parsed: " << elementName << " / " << xml.text().toString();
     return xml.text().toString();
 }
 
-Phrase * CourseParser::parsePhrase(QDomElement phraseNode, Unit* parentUnit)
-{
-    const ICourse *course = parentUnit->course();
-    Q_ASSERT(course != nullptr);
-
-    Phrase *phrase = new Phrase(parentUnit);
-    phrase->setId(phraseNode.firstChildElement(QStringLiteral("id")).text());
-    phrase->setText(phraseNode.firstChildElement(QStringLiteral("text")).text());
-    phrase->seti18nText(phraseNode.firstChildElement(QStringLiteral("i18nText")).text());
-    phrase->setUnit(parentUnit);
-    if (!phraseNode.firstChildElement(QStringLiteral("soundFile")).text().isEmpty()) {
-        phrase->setSound(QUrl::fromLocalFile(
-                course->file().adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path()
-                + '/' + phraseNode.firstChildElement(QStringLiteral("soundFile")).text())
-            );
-    }
-    phrase->setType(phraseNode.firstChildElement(QStringLiteral("type")).text());
-    phrase->setEditState(phraseNode.firstChildElement(QStringLiteral("editState")).text());
-    if (!phraseNode.firstChildElement(QStringLiteral("foreignId")).isNull()) {
-        phrase->setForeignId(phraseNode.firstChildElement(QStringLiteral("foreignId")).text());
-    }
-
-    // add phonemes
-    QList<Phoneme *> phonemes = course->language()->phonemes();
-    for (QDomElement phonemeID = phraseNode.firstChildElement(QStringLiteral("phonemes")).firstChildElement();
-        !phonemeID.isNull();
-            phonemeID = phonemeID.nextSiblingElement())
-    {
-        QString id = phonemeID.text();
-        if (id.isEmpty()) {
-            qCritical() << "Phoneme ID string is empty for phrase "<< phrase->id() <<", aborting.";
-            continue;
-        }
-        for (Phoneme *phoneme : phonemes) {
-            if (phoneme->id() == id) {
-                phrase->addPhoneme(phoneme);
-                break;
-            }
-        }
-    }
-
-    if (!phraseNode.firstChildElement(QStringLiteral("excluded")).isNull() &&
-        phraseNode.firstChildElement(QStringLiteral("excluded")).text() == QLatin1String("true"))
-    {
-        phrase->setExcluded(true);
-    }
-
-    return phrase;
-}
 
 QDomDocument CourseParser::serializedDocument(ICourse *course, bool trainingExport)
 {
     QDomDocument document;
     // prepare xml header
     QDomProcessingInstruction header = document.createProcessingInstruction(QStringLiteral("xml"), QStringLiteral("version=\"1.0\""));
     document.appendChild(header);
 
     // create main element
     QDomElement root = document.createElement(QStringLiteral("course"));
     document.appendChild(root);
 
     QDomElement idElement = document.createElement(QStringLiteral("id"));
     QDomElement titleElement = document.createElement(QStringLiteral("title"));
     QDomElement descriptionElement = document.createElement(QStringLiteral("description"));
     QDomElement languageElement = document.createElement(QStringLiteral("language"));
 
     idElement.appendChild(document.createTextNode(course->id()));
     titleElement.appendChild(document.createTextNode(course->title()));
     descriptionElement.appendChild(document.createTextNode(course->description()));
     languageElement.appendChild(document.createTextNode(course->id()));
 
     QDomElement unitListElement = document.createElement(QStringLiteral("units"));
     // create units
     for (Unit *unit : course->unitList()) {
         QDomElement unitElement = document.createElement(QStringLiteral("unit"));
 
         QDomElement unitIdElement = document.createElement(QStringLiteral("id"));
         QDomElement unitTitleElement = document.createElement(QStringLiteral("title"));
         QDomElement unitPhraseListElement = document.createElement(QStringLiteral("phrases"));
         unitIdElement.appendChild(document.createTextNode(unit->id()));
         unitTitleElement.appendChild(document.createTextNode(unit->title()));
 
         // construct phrases
         for (Phrase *phrase : unit->phraseList()) {
             if (trainingExport && phrase->soundFileUrl().isEmpty()) {
                 continue;
             }
             unitPhraseListElement.appendChild(serializedPhrase(phrase, document));
         }
 
         if (trainingExport && unitPhraseListElement.childNodes().count() == 0) {
             continue;
         }
 
         // construct the unit element
         unitElement.appendChild(unitIdElement);
         if (!unit->foreignId().isEmpty()) {
             QDomElement unitForeignIdElement = document.createElement(QStringLiteral("foreignId"));
             unitForeignIdElement.appendChild(document.createTextNode(unit->foreignId()));
             unitElement.appendChild(unitForeignIdElement);
         }
         unitElement.appendChild(unitTitleElement);
         unitElement.appendChild(unitPhraseListElement);
 
         unitListElement.appendChild(unitElement);
     }
 
     root.appendChild(idElement);
     if (!course->foreignId().isEmpty()) {
         QDomElement courseForeignIdElement = document.createElement(QStringLiteral("foreignId"));
         courseForeignIdElement.appendChild(document.createTextNode(course->foreignId()));
         root.appendChild(courseForeignIdElement);
     }
     root.appendChild(titleElement);
     root.appendChild(descriptionElement);
     root.appendChild(languageElement);
     root.appendChild(unitListElement);
 
     return document;
 }
 
 QDomElement CourseParser::serializedPhrase(Phrase *phrase, QDomDocument &document)
 {
     QDomElement phraseElement = document.createElement(QStringLiteral("phrase"));
     QDomElement phraseIdElement = document.createElement(QStringLiteral("id"));
     QDomElement phraseTextElement = document.createElement(QStringLiteral("text"));
     QDomElement phrasei18nTextElement = document.createElement(QStringLiteral("i18nText"));
     QDomElement phraseSoundFileElement = document.createElement(QStringLiteral("soundFile"));
     QDomElement phraseTypeElement = document.createElement(QStringLiteral("type"));
     QDomElement phraseEditStateElement = document.createElement(QStringLiteral("editState"));
     QDomElement phrasePhonemeListElement = document.createElement(QStringLiteral("phonemes"));
 
     phraseIdElement.appendChild(document.createTextNode(phrase->id()));
     phraseTextElement.appendChild(document.createTextNode(phrase->text()));
     phrasei18nTextElement.appendChild(document.createTextNode(phrase->i18nText()));
     phraseSoundFileElement.appendChild(document.createTextNode(phrase->sound().fileName()));
     phraseTypeElement.appendChild(document.createTextNode(phrase->typeString()));
     phraseEditStateElement.appendChild(document.createTextNode(phrase->editStateString()));
 
     // add phonemes
     foreach (Phoneme *phoneme, phrase->phonemes()) {
         QDomElement phonemeElement = document.createElement(QStringLiteral("phonemeID"));
         phonemeElement.appendChild(document.createTextNode(phoneme->id()));
         phrasePhonemeListElement.appendChild(phonemeElement);
     }
 
     phraseElement.appendChild(phraseIdElement);
     if (!phrase->foreignId().isEmpty()) {
         QDomElement phraseForeignIdElement = document.createElement(QStringLiteral("foreignId"));
         phraseForeignIdElement.appendChild(document.createTextNode(phrase->foreignId()));
         phraseElement.appendChild(phraseForeignIdElement);
     }
     phraseElement.appendChild(phraseTextElement);
     phraseElement.appendChild(phrasei18nTextElement);
     phraseElement.appendChild(phraseSoundFileElement);
     phraseElement.appendChild(phraseTypeElement);
     phraseElement.appendChild(phraseEditStateElement);
     phraseElement.appendChild(phrasePhonemeListElement);
 
     if (phrase->isExcluded()) {
         QDomElement phraseIsExcludedElement = document.createElement(QStringLiteral("excluded"));
         phraseIsExcludedElement.appendChild(document.createTextNode(QStringLiteral("true")));
         phraseElement.appendChild(phraseIsExcludedElement);
     }
 
     return phraseElement;
 }
 
 bool CourseParser::exportCourseToGhnsPackage(ICourse *course, const QString &exportPath)
 {
     // filename
     const QString fileName = course->id() + ".tar.bz2";
     KTar tar = KTar(exportPath + '/' + fileName, QStringLiteral("application/x-bzip"));
     if (!tar.open(QIODevice::WriteOnly)) {
         qCWarning(ARTIKULATE_CORE()) << "Unable to open tar file"
             << exportPath + '/' + fileName
             << "in write mode, aborting.";
         return false;
     }
 
     for (auto *unit : course->unitList()) {
         for (auto *phrase : unit->phraseList()) {
             if (QFile::exists(phrase->soundFileUrl())) {
                 tar.addLocalFile(phrase->soundFileUrl(), phrase->id() + ".ogg");
             }
         }
     }
 
     tar.writeFile(course->id() + ".xml", CourseParser::serializedDocument(course, true).toByteArray());
 
     tar.close();
     return true;
 }
diff --git a/src/core/resources/courseparser.h b/src/core/resources/courseparser.h
index 53eb598..88598f8 100644
--- a/src/core/resources/courseparser.h
+++ b/src/core/resources/courseparser.h
@@ -1,75 +1,73 @@
 /*
  *  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 COURSEPARSER_H
 #define COURSEPARSER_H
 
 #include "artikulatecore_export.h"
 #include <memory>
 #include <QVector>
 
 class ICourse;
 class Unit;
 class Phrase;
 class QXmlSchema;
 class QJSonDocument;
 class QDomDocument;
 class QDomElement;
 class QXmlStreamReader;
 class QString;
 class QUrl;
 
 class ARTIKULATECORE_EXPORT CourseParser
 {
 
 public:
     /**
      * Load XSD file given by its file name (without ".xsd" suffix). The method searches exclusively
      * the standard install dir for XSD files in subdirectory "schemes/".
      *
      * \param schemeName name of the Xml schema without suffix
      * \return loaded XML Schema
      */
     static QXmlSchema loadXmlSchema(const QString &schemeName);
 
     /**
      * Load XML file given by \p file that confirms with XML schema \p scheme.
      *
      * \param path is the path to the XML file to be loaded
      * \param scheme is the XML schema describing the DOM
      * \return the loaded DOM document
      */
     static QDomDocument loadDomDocument(const QUrl &path, const QXmlSchema &schema);
 
     static std::vector<std::unique_ptr<Unit>> parseUnits(const QUrl &path);
 
-    static Phrase * parsePhrase(QDomElement phraseNode, Unit* parentUnit);
     static QDomDocument serializedDocument(ICourse *course, bool trainingExport);
     static QDomElement serializedPhrase(Phrase *phrase, QDomDocument &document);
     static bool exportCourseToGhnsPackage(ICourse *course, const QString &exportPath);
 
 private:
-    static std::unique_ptr<Unit> parseUnit(QXmlStreamReader &xml, bool &ok);
-    static Phrase * parsePhrase(QXmlStreamReader &xml, bool &ok);
+    static std::unique_ptr<Unit> parseUnit(QXmlStreamReader &xml, const QUrl &path, bool &ok);
+    static Phrase * parsePhrase(QXmlStreamReader &xml, const QUrl &path, bool &ok);
     static QString parseElement(QXmlStreamReader &xml, bool &ok);
-
 };
 
 #endif
diff --git a/src/core/resources/courseresource.cpp b/src/core/resources/courseresource.cpp
index 0d6f167..ead8ea5 100644
--- a/src/core/resources/courseresource.cpp
+++ b/src/core/resources/courseresource.cpp
@@ -1,316 +1,277 @@
 /*
  *  Copyright 2013-2015  Andreas Cord-Landwehr <cordlandwehr@kde.org>
  *  Copyright 2013       Oindrila Gupta <oindrila.gupta92@gmail.com>
  *
  *  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 "courseresource.h"
 #include "courseparser.h"
 #include "core/language.h"
 #include "core/unit.h"
 #include "core/phoneme.h"
 #include "core/phonemegroup.h"
 #include "core/language.h"
 #include "core/iresourcerepository.h"
 
 #include <memory>
 #include <QQmlEngine>
 #include <QXmlSchema>
 #include <QXmlStreamReader>
 #include <QDomDocument>
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 
 #include "artikulate_debug.h"
 
 class CourseResourcePrivate
 {
 public:
     CourseResourcePrivate() = default;
     ~CourseResourcePrivate();
 
     void loadCourse(CourseResource *parent);
 
     IResourceRepository *m_repository{ nullptr };
     QUrl m_file;
     QString m_identifier;
     QString m_foreignId;
     QString m_title;
     QString m_languageId;
     std::shared_ptr<Language> m_language;
     QString m_i18nTitle;
     QString m_description;
     QVector<std::shared_ptr<Unit>> m_units;
     bool m_courseLoaded{ false }; ///<! indicates if course was completely parsed
 };
 
 CourseResourcePrivate::~CourseResourcePrivate() = default;
 
 void CourseResourcePrivate::loadCourse(CourseResource *parent)
 {
     if (m_courseLoaded == true) {
         qCWarning(ARTIKULATE_CORE()) << "Skipping loading of course, no reloading implemented yet";
         return;
     }
     m_courseLoaded = true;
 
     QFileInfo info(m_file.toLocalFile());
     if (!info.exists()) {
         qCCritical(ARTIKULATE_CORE()) << "No course file available at location" << m_file.toLocalFile();
         return;
     }
 
-    // load existing file
-    QXmlSchema schema = CourseParser::loadXmlSchema(QStringLiteral("course"));
-    if (!schema.isValid()) {
-        qCWarning(ARTIKULATE_CORE()) << "Scheme not valid, aborting";
-        return;
-    }
-    QDomDocument document = CourseParser::loadDomDocument(m_file, schema);
-    if (document.isNull()) {
-        qCWarning(ARTIKULATE_CORE()) << "Could not parse document " << m_file.toLocalFile() << ", aborting.";
-        return;
-    }
-
-    // load missing elements of course
-    // TODO usage of QDomElement is quite slow and should be exchanged with the QXmlParser in the future
-    QDomElement root(document.documentElement());
-
-    if (!root.firstChildElement(QStringLiteral("foreignId")).isNull()) {
-        m_foreignId = root.firstChildElement(QStringLiteral("foreignId")).text();
-    }
-
-    // create units
-    for (QDomElement unitNode = root.firstChildElement(QStringLiteral("units")).firstChildElement();
-         !unitNode.isNull();
-         unitNode = unitNode.nextSiblingElement())
-    {
-        std::unique_ptr<Unit> unit(new Unit);
-        unit->setId(unitNode.firstChildElement(QStringLiteral("id")).text());
-        unit->setCourse(parent);
-        unit->setTitle(unitNode.firstChildElement(QStringLiteral("title")).text());
-        if (!unitNode.firstChildElement(QStringLiteral("foreignId")).isNull()) {
-            unit->setForeignId(unitNode.firstChildElement(QStringLiteral("foreignId")).text());
-        }
-
-        // create phrases
-        for (QDomElement phraseNode = unitNode.firstChildElement(QStringLiteral("phrases")).firstChildElement();
-            !phraseNode.isNull();
-            phraseNode = phraseNode.nextSiblingElement())
-        {
-            unit->addPhrase(CourseParser::parsePhrase(phraseNode, unit.get())); // add to unit at last step to produce only one signal
-            //FIXME phrase does not cause unit signals that phonemes list is changed
-        }
+    auto units = CourseParser::parseUnits(m_file);
+    for (auto &unit : units) {
         parent->addUnit(std::move(unit));
     }
 }
 
 CourseResource::CourseResource(const QUrl &path, IResourceRepository *repository)
     : ICourse(repository)
     , d(new CourseResourcePrivate())
 {
     QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
     d->m_file = path;
     d->m_repository = repository;
 
     // load basic information from language file, but does not parse everything
     QXmlStreamReader xml;
     QFile file(path.toLocalFile());
     if (file.open(QIODevice::ReadOnly)) {
         xml.setDevice(&file);
         xml.readNextStartElement();
         while (xml.readNext() && !xml.atEnd()) {
             if (xml.name() == "id") {
                 d->m_identifier = xml.readElementText();
                 continue;
             }
             if (xml.name() == "foreignId") {
                 d->m_foreignId = xml.readElementText();
                 continue;
             }
             //TODO i18nTitle must be implemented, currently missing and hence not parsed
             if (xml.name() == "title") {
                 d->m_title = xml.readElementText();
                 d->m_i18nTitle = d->m_title;
                 continue;
             }
             if (xml.name() == "description") {
                 d->m_description = xml.readElementText();
                 continue;
             }
             if (xml.name() == "language") {
                 d->m_languageId = xml.readElementText();
                 continue;
             }
 
             // quit reading when basic elements are read
             if (!d->m_identifier.isEmpty()
                 && !d->m_title.isEmpty()
                 && !d->m_i18nTitle.isEmpty()
                 && !d->m_description.isEmpty()
                 && !d->m_languageId.isEmpty()
                 && !d->m_foreignId.isEmpty()
             )
             {
                 break;
             }
         }
         if (xml.hasError()) {
             qCritical() << "Error occurred when reading Course XML file:" << path.toLocalFile();
         }
     } else {
         qCCritical(ARTIKULATE_CORE()) << "Could not open course file" << path.toLocalFile();
     }
     xml.clear();
     file.close();
 
     // find correct language
     if (repository != nullptr) {
         for (const auto &language : repository->languages()) {
             if (language == nullptr) {
                 continue;
             }
             if (language->id() == d->m_languageId) {
                 d->m_language = language;
             }
         }
     }
     if (d->m_language == nullptr) {
         qCCritical(ARTIKULATE_CORE()) << "A course with an unknown language was loaded";
     }
 }
 
 CourseResource::~CourseResource() = default;
 
 QString CourseResource::id() const
 {
     return d->m_identifier;
 }
 
 void CourseResource::setId(const QString &id)
 {
     if (d->m_identifier == id) {
         return;
     }
     d->m_identifier = id;
     emit idChanged();
 }
 
 QString CourseResource::foreignId() const
 {
     return d->m_foreignId;
 }
 
 void CourseResource::setForeignId(const QString &foreignId)
 {
     if (d->m_foreignId == foreignId) {
         return;
     }
     d->m_foreignId = foreignId;
     emit foreignIdChanged();
 }
 
 QString CourseResource::title() const
 {
     return d->m_title;
 }
 
 void CourseResource::setTitle(const QString &title)
 {
     if (d->m_title == title) {
         return;
     }
     d->m_title = title;
     emit titleChanged();
 }
 
 QString CourseResource::i18nTitle() const
 {
     return d->m_i18nTitle;
 }
 
 void CourseResource::setI18nTitle(const QString &i18nTitle)
 {
     if (d->m_i18nTitle == i18nTitle) {
         return;
     }
     d->m_i18nTitle = i18nTitle;
     emit i18nTitleChanged();
 }
 
 QString CourseResource::description() const
 {
     return d->m_description;
 }
 
 void CourseResource::setDescription(const QString &description)
 {
     if (d->m_description == description) {
         return;
     }
     d->m_description = description;
     emit descriptionChanged();
 }
 
 std::shared_ptr<Language> CourseResource::language() const
 {
     return d->m_language;
 }
 
 void CourseResource::setLanguage(std::shared_ptr<Language> language)
 {
     if (d->m_language == language) {
         return;
     }
     d->m_language = language;
     emit languageChanged();
 }
 
 std::shared_ptr<Unit> CourseResource::addUnit(std::unique_ptr<Unit> unit)
 {
     emit unitAboutToBeAdded(unit.get(), d->m_units.count() - 1);
     d->m_units.append(std::move(unit));
     emit unitAdded();
     return d->m_units.last();
 }
 
 QList<Unit *> CourseResource::unitList()
 {
     if (d->m_courseLoaded == false) {
         d->loadCourse(this);
     }
     QList<Unit *> rawList;
     for (auto unit : d->m_units) {
         rawList.append(unit.get());
     }
     return rawList;
 }
 
 QVector<std::shared_ptr<Unit>> CourseResource::units()
 {
     if (d->m_courseLoaded == false) {
         d->loadCourse(this);
     }
     return d->m_units;
 }
 
 QUrl CourseResource::file() const
 {
     return d->m_file;
 }