diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -7,6 +7,9 @@
 # Our Qt Quick plugin
 add_subdirectory(qtquick)
 
+# Comon helper library shared between app and creator.
+add_subdirectory(common)
+
 # Base application
 add_subdirectory(app)
 
diff --git a/src/acbf/AcbfAuthor.h b/src/acbf/AcbfAuthor.h
--- a/src/acbf/AcbfAuthor.h
+++ b/src/acbf/AcbfAuthor.h
@@ -23,6 +23,7 @@
 #define ACBFAUTHORINFO_H
 
 #include "AcbfMetadata.h"
+#include <memory>
 
 namespace AdvancedComicBookFormat
 {
@@ -32,36 +33,36 @@
 public:
     // Author is used in both Bookinfo and Documentinfo, and as such it is parented to Metadata
     explicit Author(Metadata* parent = nullptr);
-    ~Author() override;
+    ~Author();
 
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    Q_INVOKABLE QString displayName();
+    Q_INVOKABLE QString displayName() const;
 
-    Q_INVOKABLE QString activity();
-    Q_INVOKABLE void setActivity(QString activity);
+    Q_INVOKABLE QString activity() const;
+    Q_INVOKABLE void setActivity(const QString& activity);
     Q_INVOKABLE static QStringList availableActivities();
 
     // The language this author worked in for this book. Activity dependent (writer, translator, letterer...)
-    Q_INVOKABLE QString language();
-    Q_INVOKABLE void setLanguage(QString language = "");
+    Q_INVOKABLE QString language() const;
+    Q_INVOKABLE void setLanguage(const QString& language = QString());
 
-    Q_INVOKABLE QString firstName();
-    Q_INVOKABLE void setFirstName(QString name);
-    Q_INVOKABLE QString middleName();
-    Q_INVOKABLE void setMiddleName(QString name);
-    Q_INVOKABLE QString lastName();
-    Q_INVOKABLE void setLastName(QString name);
-    Q_INVOKABLE QString nickName();
-    Q_INVOKABLE void setNickName(QString name);
-    Q_INVOKABLE QString homePage();
-    Q_INVOKABLE void setHomePage(QString homepage);
-    Q_INVOKABLE QString email();
-    Q_INVOKABLE void setEmail(QString email);
+    Q_INVOKABLE QString firstName() const;
+    Q_INVOKABLE void setFirstName(const QString& name);
+    Q_INVOKABLE QString middleName() const;
+    Q_INVOKABLE void setMiddleName(const QString& name);
+    Q_INVOKABLE QString lastName() const;
+    Q_INVOKABLE void setLastName(const QString& name);
+    Q_INVOKABLE QString nickName() const;
+    Q_INVOKABLE void setNickName(const QString& name);
+    Q_INVOKABLE QString homePage() const;
+    Q_INVOKABLE void setHomePage(const QString& homepage);
+    Q_INVOKABLE QString email() const;
+    Q_INVOKABLE void setEmail(const QString& email);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfAuthor.cpp b/src/acbf/AcbfAuthor.cpp
--- a/src/acbf/AcbfAuthor.cpp
+++ b/src/acbf/AcbfAuthor.cpp
@@ -42,23 +42,20 @@
 
 Author::Author(Metadata* parent)
     : QObject(parent)
-    , d(new Private)
+    , d(new Private())
 {
     qRegisterMetaType<Author*>("Author*");
 }
 
-Author::~Author()
-{
-    delete d;
-}
+Author::~Author() = default;
 
-QString Author::displayName()
+QString Author::displayName() const
 {
     if(!d->nickName.isEmpty()) {
         return d->nickName;
     }
     else if(!d->firstName.isEmpty() || !d->middleName.isEmpty() || !d->lastName.isEmpty()) {
-        return QString("%1 %2 %3").arg(d->firstName).arg(d->middleName).arg(d->lastName).simplified();
+        return QStringLiteral("%1 %2 %3").arg(d->firstName).arg(d->middleName).arg(d->lastName).simplified();
     }
     else if(!d->email.isEmpty()) {
         return d->email;
@@ -71,51 +68,51 @@
 
 void Author::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("author");
+    writer->writeStartElement(QStringLiteral("author"));
     if(!d->activity.isEmpty()) {
-        writer->writeAttribute("activity", d->activity);
+        writer->writeAttribute(QStringLiteral("activity"), d->activity);
     }
     if(!d->language.isEmpty()) {
-        writer->writeAttribute("lang", d->language);
+        writer->writeAttribute(QStringLiteral("lang"), d->language);
     }
 
-    writer->writeTextElement("first-name", d->firstName);
-    writer->writeTextElement("middle-name", d->middleName);
-    writer->writeTextElement("last-name", d->lastName);
-    writer->writeTextElement("nickname", d->nickName);
-    writer->writeTextElement("home-page", d->homePage);
-    writer->writeTextElement("email", d->email);
+    writer->writeTextElement(QStringLiteral("first-name"), d->firstName);
+    writer->writeTextElement(QStringLiteral("middle-name"), d->middleName);
+    writer->writeTextElement(QStringLiteral("last-name"), d->lastName);
+    writer->writeTextElement(QStringLiteral("nickname"), d->nickName);
+    writer->writeTextElement(QStringLiteral("home-page"), d->homePage);
+    writer->writeTextElement(QStringLiteral("email"), d->email);
 
     writer->writeEndElement();  
 }
 
 bool Author::fromXml(QXmlStreamReader *xmlReader)
 {
-    setActivity(xmlReader->attributes().value("activity").toString());
-    setLanguage(xmlReader->attributes().value("lang").toString());
+    setActivity(xmlReader->attributes().value(QStringLiteral("activity")).toString());
+    setLanguage(xmlReader->attributes().value(QStringLiteral("lang")).toString());
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "first-name")
+        if(xmlReader->name() == QStringLiteral("first-name"))
         {
             setFirstName(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "middle-name")
+        else if(xmlReader->name() == QStringLiteral("middle-name"))
         {
             setMiddleName(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "last-name")
+        else if(xmlReader->name() == QStringLiteral("last-name"))
         {
             setLastName(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "nickname")
+        else if(xmlReader->name() == QStringLiteral("nickname"))
         {
             setNickName(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "home-page")
+        else if(xmlReader->name() == QStringLiteral("home-page"))
         {
             setHomePage(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "email")
+        else if(xmlReader->name() == QStringLiteral("email"))
         {
             setEmail(xmlReader->readElementText());
         }
@@ -132,101 +129,101 @@
     return !xmlReader->hasError();
 }
 
-QString Author::activity()
+QString Author::activity() const
 {
     return d->activity;
 }
 
-void Author::setActivity(QString activity)
+void Author::setActivity(const QString& activity)
 {
     d->activity = activity;
 }
 
 QStringList Author::availableActivities()
 {
-    QStringList activities;
-    activities << "Writer"; // (story was written by)
-    activities << "Adapter"; // (in case the comic book story is adaptation of story written by someone else)
-    activities << "Artist"; // (art was drawn by)
-    activities << "Penciller"; // (penciller, inker, colorist and leterrer attribute value may be used in case art was created in collaboration by a group of different artists)
-    activities << "Inker";
-    activities << "Colorist";
-    activities << "Letterer"; // (in case texts are handwritten)
-    activities << "CoverArtist"; // (created comic book cover)
-    activities << "Photographer"; // /new in 1.1/
-    activities << "Editor";
-    activities << "Assistant Editor"; // /new in 1.1/
-    activities << "Translator";
-    activities << "Other"; // /new in 1.1/
-    return activities;
-}
-
-QString Author::language()
+    return {
+        QStringLiteral("Writer"), // (story was written by)
+        QStringLiteral("Adapter"), // (in case the comic book story is adaptation of story written by someone else)
+        QStringLiteral("Artist"), // (art was drawn by)
+        QStringLiteral("Penciller"), // (penciller, inker, colorist and leterrer attribute value may be used in case art was created in collaboration by a group of different artists)
+        QStringLiteral("Inker"),
+        QStringLiteral("Colorist"),
+        QStringLiteral("Letterer"), // (in case texts are handwritten)
+        QStringLiteral("CoverArtist"), // (created comic book cover)
+        QStringLiteral("Photographer"), // /new in 1.1/
+        QStringLiteral("Editor"),
+        QStringLiteral("Assistant Editor"), // /new in 1.1/
+        QStringLiteral("Translator"),
+        QStringLiteral("Other") // /new in 1.1/
+    };
+}
+
+QString Author::language() const
 {
     return d->language;
 }
 
-void Author::setLanguage(QString language)
+void Author::setLanguage(const QString& language)
 {
     d->language = language;
 }
 
-QString Author::firstName()
+QString Author::firstName() const
 {
     return d->firstName;
 }
 
-void Author::setFirstName(QString name)
+void Author::setFirstName(const QString& name)
 {
     d->firstName = name;
 }
 
-QString Author::middleName()
+QString Author::middleName() const
 {
     return d->middleName;
 }
 
-void Author::setMiddleName(QString name)
+void Author::setMiddleName(const QString& name)
 {
     d->middleName = name;
 }
 
-QString Author::lastName()
+QString Author::lastName() const
 {
     return d->lastName;
 }
 
-void Author::setLastName(QString name)
+void Author::setLastName(const QString& name)
 {
     d->lastName = name;
 }
 
-QString Author::nickName()
+QString Author::nickName() const
 {
     return d->nickName;
 }
 
-void Author::setNickName(QString name)
+void Author::setNickName(const QString& name)
 {
     d->nickName = name;
 }
 
-QString Author::homePage()
+QString Author::homePage() const
 {
     return d->homePage;
 }
 
-void Author::setHomePage(QString homepage)
+void Author::setHomePage(const QString& homepage)
 {
     d->homePage = homepage;
 }
 
-QString Author::email()
+QString Author::email() const
 {
     return d->email;
 }
 
-void Author::setEmail(QString email)
+void Author::setEmail(const QString& email)
 {
     d->email = email;
 }
diff --git a/src/acbf/AcbfBinary.h b/src/acbf/AcbfBinary.h
--- a/src/acbf/AcbfBinary.h
+++ b/src/acbf/AcbfBinary.h
@@ -22,6 +22,8 @@
 #ifndef ACBFBINARY_H
 #define ACBFBINARY_H
 
+#include <memory>
+
 #include <QObject>
 
 #include "acbf_export.h"
@@ -42,17 +44,17 @@
     void toXml(QXmlStreamWriter *writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString id();
-    void setId(QString newId);
+    QString id() const;
+    void setId(const QString& newId);
 
-    QString contentType();
-    void setContentType(QString newContentType);
+    QString contentType() const;
+    void setContentType(const QString& newContentType);
 
-    QByteArray data();
-    void setData(QByteArray newData);
+    QByteArray data() const;
+    void setData(const QByteArray& newData);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfBinary.cpp b/src/acbf/AcbfBinary.cpp
--- a/src/acbf/AcbfBinary.cpp
+++ b/src/acbf/AcbfBinary.cpp
@@ -45,57 +45,54 @@
     qRegisterMetaType<Binary*>("Binary*");
 }
 
-Binary::~Binary()
-{
-    delete d;
-}
+Binary::~Binary() = default;
 
 void Binary::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("binary");
+    writer->writeStartElement(QStringLiteral("binary"));
 
-    writer->writeAttribute("id", id());
-    writer->writeAttribute("contentType", contentType());
+    writer->writeAttribute(QStringLiteral("id"), id());
+    writer->writeAttribute(QStringLiteral("contentType"), contentType());
     writer->writeCharacters(QString::fromLatin1(data().toBase64()));
 
     writer->writeEndElement();
 }
 
 bool Binary::fromXml(QXmlStreamReader* xmlReader)
 {
-    setId(xmlReader->attributes().value("id").toString());
-    setContentType(xmlReader->attributes().value("content-type").toString());
+    setId(xmlReader->attributes().value(QStringLiteral("id")).toString());
+    setContentType(xmlReader->attributes().value(QStringLiteral("content-type")).toString());
     setData(QByteArray::fromBase64(xmlReader->readElementText().toLatin1()));
 
     return !xmlReader->hasError();
 }
 
-QString Binary::id()
+QString Binary::id() const
 {
     return d->id;
 }
 
-void Binary::setId(QString newId)
+void Binary::setId(const QString& newId)
 {
     d->id = newId;
 }
 
-QString Binary::contentType()
+QString Binary::contentType() const
 {
     return d->contentType;
 }
 
-void Binary::setContentType(QString newContentType)
+void Binary::setContentType(const QString& newContentType)
 {
     d->contentType = newContentType;
 }
 
-QByteArray Binary::data()
+QByteArray Binary::data() const
 {
     return d->data;
 }
 
-void Binary::setData(QByteArray newData)
+void Binary::setData(const QByteArray& newData)
 {
     d->data = newData;
 }
diff --git a/src/acbf/AcbfBody.h b/src/acbf/AcbfBody.h
--- a/src/acbf/AcbfBody.h
+++ b/src/acbf/AcbfBody.h
@@ -22,6 +22,8 @@
 #ifndef ACBFBODY_H
 #define ACBFBODY_H
 
+#include <memory>
+
 #include "AcbfDocument.h"
 
 #include <QDate>
@@ -36,26 +38,28 @@
     Q_OBJECT
 public:
     explicit Body(Document* parent = nullptr);
-    ~Body() override;
+    ~Body();
 
-    Document* document();
+    Document* document() const;
 
     void toXml(QXmlStreamWriter *writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString bgcolor();
-    void setBgcolor(QString newColor);
+    QString bgcolor() const;
+    void setBgcolor(const QString& newColor);
+
+    QList<Page*> pages() const;
+    Page* page(int index) const;
+    int pageIndex(Page* page) const;
 
-    QList<Page*> pages();
-    Page* page(int index);
-    int pageIndex(Page* page);
     // If afterIndex is larger than zero, the insertion will happen at that index
     void addPage(Page* page, int index = -1);
     void removePage(Page* page);
     bool swapPages(Page* swapThis, Page* withThis);
+
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfBody.cpp b/src/acbf/AcbfBody.cpp
--- a/src/acbf/AcbfBody.cpp
+++ b/src/acbf/AcbfBody.cpp
@@ -42,19 +42,16 @@
     qRegisterMetaType<Body*>("Body*");
 }
 
-Body::~Body()
-{
-    delete d;
-}
+Body::~Body() = default;
 
-Document * Body::document()
+Document * Body::document() const
 {
     return qobject_cast<Document*>(parent());
 }
 
 void Body::toXml(QXmlStreamWriter *writer)
 {
-    writer->writeStartElement("body");
+    writer->writeStartElement(QStringLiteral("body"));
 
     Q_FOREACH(Page* page, d->pages) {
         page->toXml(writer);
@@ -65,10 +62,10 @@
 
 bool Body::fromXml(QXmlStreamReader *xmlReader)
 {
-    setBgcolor(xmlReader->attributes().value("bgcolor").toString());
+    setBgcolor(xmlReader->attributes().value(QStringLiteral("bgcolor")).toString());
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "page")
+        if(xmlReader->name() == QStringLiteral("page"))
         {
             Page* newPage = new Page(document());
             if(!newPage->fromXml(xmlReader)) {
@@ -89,27 +86,27 @@
     return !xmlReader->hasError();
 }
 
-QString Body::bgcolor()
+QString Body::bgcolor() const
 {
     return d->bgcolor;
 }
 
-void Body::setBgcolor(QString newColor)
+void Body::setBgcolor(const QString& newColor)
 {
     d->bgcolor = newColor;
 }
 
-QList<Page *> Body::pages()
+QList<Page *> Body::pages() const
 {
     return d->pages;
 }
 
-Page * Body::page(int index)
+Page * Body::page(int index) const
 {
     return d->pages.at(index);
 }
 
-int Body::pageIndex(Page* page)
+int Body::pageIndex(Page* page) const
 {
     return d->pages.indexOf(page);
 }
diff --git a/src/acbf/AcbfBookinfo.h b/src/acbf/AcbfBookinfo.h
--- a/src/acbf/AcbfBookinfo.h
+++ b/src/acbf/AcbfBookinfo.h
@@ -22,6 +22,8 @@
 #ifndef ACBFBOOKINFO_H
 #define ACBFBOOKINFO_H
 
+#include <memory>
+
 #include "AcbfMetadata.h"
 
 #include <QHash>
@@ -108,7 +110,7 @@
     void removeContentRating(ContentRating* contentRating);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfBookinfo.cpp b/src/acbf/AcbfBookinfo.cpp
--- a/src/acbf/AcbfBookinfo.cpp
+++ b/src/acbf/AcbfBookinfo.cpp
@@ -61,38 +61,35 @@
     d->coverPage->setIsCoverPage(true);
 }
 
-BookInfo::~BookInfo()
-{
-    delete d;
-}
+BookInfo::~BookInfo() = default;
 
 Metadata * BookInfo::metadata()
 {
     return qobject_cast<Metadata*>(parent());
 }
 
 void BookInfo::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("book-info");
+    writer->writeStartElement(QStringLiteral("book-info"));
 
     Q_FOREACH(Author* author, d->author) {
         author->toXml(writer);
     }
 
     QHashIterator<QString, QString> titles(d->title);
     while(titles.hasNext()) {
         titles.next();
-        writer->writeStartElement("book-title");
-        writer->writeAttribute("lang", titles.key());
+        writer->writeStartElement(QStringLiteral("book-title"));
+        writer->writeAttribute(QStringLiteral("lang"), titles.key());
         writer->writeCharacters(titles.value());
         writer->writeEndElement();
     }
 
     QHashIterator<QString, int> genres(d->genre);
     while(genres.hasNext()) {
         genres.next();
-        writer->writeStartElement("genre");
-        writer->writeAttribute("match", QString::number(genres.value()));
+        writer->writeStartElement(QStringLiteral("genre"));
+        writer->writeAttribute(QStringLiteral("match"), QString::number(genres.value()));
         writer->writeCharacters(genres.key());
         writer->writeEndElement();
     }
@@ -109,10 +106,10 @@
     QHashIterator<QString, QStringList> annotations(d->annotation);
     while(annotations.hasNext()) {
         annotations.next();
-        writer->writeStartElement("annotation");
-        writer->writeAttribute("lang", annotations.key());
+        writer->writeStartElement(QStringLiteral("annotation"));
+        writer->writeAttribute(QStringLiteral("lang"), annotations.key());
         Q_FOREACH(const QString& paragraph, annotations.value()) {
-            writer->writeStartElement("p");
+            writer->writeStartElement(QStringLiteral("p"));
             writer->writeCharacters(paragraph);
             writer->writeEndElement();
         }
@@ -122,15 +119,15 @@
     QHashIterator<QString, QStringList> keywords(d->keywords);
     while(keywords.hasNext()) {
         keywords.next();
-        writer->writeStartElement("keywords");
-        writer->writeAttribute("lang", keywords.key());
+        writer->writeStartElement(QStringLiteral("keywords"));
+        writer->writeAttribute(QStringLiteral("lang"), keywords.key());
         writer->writeCharacters(keywords.value().join(','));
         writer->writeEndElement();
     }
 
     d->coverPage->toXml(writer);
 
-    writer->writeStartElement("languages");
+    writer->writeStartElement(QStringLiteral("languages"));
     Q_FOREACH(Language* language, d->languages) {
         language->toXml(writer);
     }
@@ -153,65 +150,65 @@
 {
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "author")
+        if(xmlReader->name() == QStringLiteral("author"))
         {
             Author* newAuthor = new Author(metadata());
             if(!newAuthor->fromXml(xmlReader)) {
                 return false;
             }
             d->author.append(newAuthor);
         }
-        else if(xmlReader->name() == "book-title")
+        else if(xmlReader->name() == QStringLiteral("book-title"))
         {
-            QString language = xmlReader->attributes().value("lang").toString();
+            QString language = xmlReader->attributes().value(QStringLiteral("lang")).toString();
             d->title[language] = xmlReader->readElementText(QXmlStreamReader::IncludeChildElements);
         }
-        else if(xmlReader->name() == "genre")
+        else if(xmlReader->name() == QStringLiteral("genre"))
         {
-            int match = xmlReader->attributes().value("match").toInt();
+            int match = xmlReader->attributes().value(QStringLiteral("match")).toInt();
             d->genre[xmlReader->readElementText(QXmlStreamReader::IncludeChildElements)] = match;
         }
-        else if(xmlReader->name() == "characters")
+        else if(xmlReader->name() == QStringLiteral("characters"))
         {
             while(xmlReader->readNextStartElement()) {
-                if(xmlReader->name() == "name") {
+                if(xmlReader->name() == QStringLiteral("name")) {
                     d->characters.append(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
                 }
                 else {
                     xmlReader->skipCurrentElement();
                 }
             }
             qDebug() << "Created character entries, we now have" << d->characters.count() << "characters";
         }
-        else if(xmlReader->name() == "annotation")
+        else if(xmlReader->name() == QStringLiteral("annotation"))
         {
-            QString language = xmlReader->attributes().value("lang").toString();
+            QString language = xmlReader->attributes().value(QStringLiteral("lang")).toString();
             QStringList paragraphs;
             while(xmlReader->readNextStartElement()) {
-                if(xmlReader->name() == "p") {
+                if(xmlReader->name() == QStringLiteral("p")) {
                     paragraphs.append(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
                 }
                 else {
                     xmlReader->skipCurrentElement();
                 }
             }
             d->annotation[language] = paragraphs;
         }
-        else if(xmlReader->name() == "keywords")
+        else if(xmlReader->name() == QStringLiteral("keywords"))
         {
-            QString language = xmlReader->attributes().value("lang").toString();
+            QString language = xmlReader->attributes().value(QStringLiteral("lang")).toString();
             d->keywords[language] = xmlReader->readElementText(QXmlStreamReader::IncludeChildElements).split(',');
         }
-        else if(xmlReader->name() == "coverpage")
+        else if(xmlReader->name() == QStringLiteral("coverpage"))
         {
             if(!d->coverPage->fromXml(xmlReader)) {
                 return false;
             }
         }
-        else if(xmlReader->name() == "languages")
+        else if(xmlReader->name() == QStringLiteral("languages"))
         {
             while(xmlReader->readNextStartElement()) {
-                if(xmlReader->name() == "text-layer") {
+                if(xmlReader->name() == QStringLiteral("text-layer")) {
                     Language* newLanguage = new Language(this);
                     newLanguage->fromXml(xmlReader);
                     d->languages.append(newLanguage);
@@ -221,19 +218,19 @@
                 }
             }
         }
-        else if(xmlReader->name() == "sequence")
+        else if(xmlReader->name() == QStringLiteral("sequence"))
         {
             Sequence* newSequence = new Sequence(this);
             newSequence->fromXml(xmlReader);
             d->sequence.append(newSequence);
         }
-        else if(xmlReader->name() == "databaseref")
+        else if(xmlReader->name() == QStringLiteral("databaseref"))
         {
             DatabaseRef* newDatabaseRef = new DatabaseRef(this);
             newDatabaseRef->fromXml(xmlReader);
             d->databaseRef.append(newDatabaseRef);
         }
-        else if(xmlReader->name() == "content-rating")
+        else if(xmlReader->name() == QStringLiteral("content-rating"))
         {
             ContentRating* newContentRating = new ContentRating(this);
             newContentRating->fromXml(xmlReader);
@@ -383,36 +380,37 @@
 
 QStringList BookInfo::availableGenres()
 {
-    QStringList genres;
-    genres << "science_fiction";
-    genres << "fantasy";
-    genres << "adventure";
-    genres << "horror";
-    genres << "mystery";
-    genres << "crime";
-    genres << "military"; // (war ...)
-    genres << "real_life";
-    genres << "superhero"; // (e.g. Superman, Spiderman … or Super Villains)
-    genres << "humor";
-    genres << "western";
-    genres << "manga";
-    genres << "politics";
-    genres << "caricature";
-    genres << "sports";
-    genres << "history"; // (historical comics)
-    genres << "biography"; // (biographical comics)
-    genres << "education"; // (education and science)
-    genres << "computer"; // (computers related)
-    genres << "religion";
-    genres << "romance";
-    genres << "children";
-    genres << "non-fiction";
-    genres << "adult";
-    genres << "alternative"; // (abstract, underground ...)
-    genres << "other";
-    return genres;
+    return {
+        QStringLiteral("science_fiction"),
+        QStringLiteral("fantasy"),
+        QStringLiteral("adventure"),
+        QStringLiteral("horror"),
+        QStringLiteral("mystery"),
+        QStringLiteral("crime"),
+        QStringLiteral("military"), // (war ...)
+        QStringLiteral("real_life"),
+        QStringLiteral("superhero"), // (e.g. Superman, Spiderman … or Super Villains)
+        QStringLiteral("humor"),
+        QStringLiteral("western"),
+        QStringLiteral("manga"),
+        QStringLiteral("politics"),
+        QStringLiteral("caricature"),
+        QStringLiteral("sports"),
+        QStringLiteral("history"), // (historical comics)
+        QStringLiteral("biography"), // (biographical comics)
+        QStringLiteral("education"), // (education and science)
+        QStringLiteral("computer"), // (computers related)
+        QStringLiteral("religion"),
+        QStringLiteral("romance"),
+        QStringLiteral("children"),
+        QStringLiteral("non-fiction"),
+        QStringLiteral("adult"),
+        QStringLiteral("alternative"), // (abstract, underground ...)
+        QStringLiteral("other")
+    };
 }
 
+
 QStringList BookInfo::characters()
 {
     return d->characters;
diff --git a/src/acbf/AcbfContentrating.h b/src/acbf/AcbfContentrating.h
--- a/src/acbf/AcbfContentrating.h
+++ b/src/acbf/AcbfContentrating.h
@@ -22,6 +22,8 @@
 #ifndef ACBFCONTENTRATING_H
 #define ACBFCONTENTRATING_H
 
+#include <memory>
+
 #include "AcbfBookinfo.h"
 
 namespace AdvancedComicBookFormat
@@ -36,14 +38,14 @@
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString type();
-    void setType(QString type);
+    QString type() const;
+    void setType(const QString& type);
 
-    QString rating();
-    void setRating(QString rating);
+    QString rating() const;
+    void setRating(const QString& rating);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfContentrating.cpp b/src/acbf/AcbfContentrating.cpp
--- a/src/acbf/AcbfContentrating.cpp
+++ b/src/acbf/AcbfContentrating.cpp
@@ -40,43 +40,40 @@
 {
 }
 
-ContentRating::~ContentRating()
-{
-    delete d;
-}
+ContentRating::~ContentRating() = default;
 
 void ContentRating::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("content-rating");
-    writer->writeAttribute("type", d->type);
+    writer->writeStartElement(QStringLiteral("content-rating"));
+    writer->writeAttribute(QStringLiteral("type"), d->type);
     writer->writeCharacters(d->rating);
     writer->writeEndElement();
 }
 
 bool ContentRating::fromXml(QXmlStreamReader *xmlReader)
 {
-    setType(xmlReader->attributes().value("type").toString());
+    setType(xmlReader->attributes().value(QStringLiteral("type")).toString());
     setRating(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
     qDebug() << Q_FUNC_INFO << "Created a content rating for" << type() << "with rating" << rating();
     return true;
 }
 
-QString ContentRating::type()
+QString ContentRating::type() const
 {
     return d->type;
 }
 
-void ContentRating::setType(QString type)
+void ContentRating::setType(const QString& type)
 {
     d->type = type;
 }
 
-QString ContentRating::rating()
+QString ContentRating::rating() const
 {
     return d->rating;
 }
 
-void ContentRating::setRating(QString rating)
+void ContentRating::setRating(const QString& rating)
 {
     d->rating = rating;
 }
diff --git a/src/acbf/AcbfData.h b/src/acbf/AcbfData.h
--- a/src/acbf/AcbfData.h
+++ b/src/acbf/AcbfData.h
@@ -22,6 +22,8 @@
 #ifndef ACBFDATA_H
 #define ACBFDATA_H
 
+#include <memory>
+
 #include <QObject>
 #include <QXmlStreamReader>
 
@@ -40,10 +42,10 @@
     void toXml(QXmlStreamWriter *writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    Binary* binary(QString id);
+    Binary* binary(const QString& id) const;
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfData.cpp b/src/acbf/AcbfData.cpp
--- a/src/acbf/AcbfData.cpp
+++ b/src/acbf/AcbfData.cpp
@@ -39,14 +39,11 @@
     qRegisterMetaType<Data*>("Data*");
 }
 
-Data::~Data()
-{
-    delete d;
-}
+Data::~Data() = default;
 
 void Data::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("data");
+    writer->writeStartElement(QStringLiteral("data"));
 
     Q_FOREACH(Binary* binary, d->binaries) {
         binary->toXml(writer);
@@ -59,7 +56,7 @@
 {
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "binary")
+        if(xmlReader->name() == QStringLiteral("binary"))
         {
             Binary* newBinary = new Binary(this);
             if(!newBinary->fromXml(xmlReader)) {
@@ -80,7 +77,7 @@
     return !xmlReader->hasError();
 }
 
-Binary* Data::binary(QString id)
+Binary* Data::binary(const QString& id) const
 {
     return d->binaries.value(id);
 }
diff --git a/src/acbf/AcbfDatabaseref.h b/src/acbf/AcbfDatabaseref.h
--- a/src/acbf/AcbfDatabaseref.h
+++ b/src/acbf/AcbfDatabaseref.h
@@ -22,6 +22,7 @@
 #ifndef ACBFDATABASEREF_H
 #define ACBFDATABASEREF_H
 
+#include <memory>
 #include "AcbfBookinfo.h"
 
 namespace AdvancedComicBookFormat
@@ -36,17 +37,17 @@
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString dbname();
-    void setDbname(QString dbname);
+    QString dbname() const;
+    void setDbname(const QString& dbname);
 
-    QString type();
-    void setType(QString type);
+    QString type() const;
+    void setType(const QString& type);
 
-    QString reference();
-    void setReference(QString reference);
+    QString reference() const;
+    void setReference(const QString& reference);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfDatabaseref.cpp b/src/acbf/AcbfDatabaseref.cpp
--- a/src/acbf/AcbfDatabaseref.cpp
+++ b/src/acbf/AcbfDatabaseref.cpp
@@ -41,57 +41,54 @@
 {
 }
 
-DatabaseRef::~DatabaseRef()
-{
-    delete d;
-}
+DatabaseRef::~DatabaseRef() = default;
 
 void DatabaseRef::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("databaseref");
-    writer->writeAttribute("dbname", d->dbname);
+    writer->writeStartElement(QStringLiteral("databaseref"));
+    writer->writeAttribute(QStringLiteral("dbname"), d->dbname);
     if(!d->type.isEmpty()) {
-        writer->writeAttribute("type", d->type);
+        writer->writeAttribute(QStringLiteral("type"), d->type);
     }
     writer->writeCharacters(d->reference);
     writer->writeEndElement();
 }
 
 bool DatabaseRef::fromXml(QXmlStreamReader *xmlReader)
 {
-    setDbname(xmlReader->attributes().value("volume").toString());
-    setType(xmlReader->attributes().value("type").toString());
+    setDbname(xmlReader->attributes().value(QStringLiteral("volume")).toString());
+    setType(xmlReader->attributes().value(QStringLiteral("type")).toString());
     setReference(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
     qDebug() << Q_FUNC_INFO << "Created a database reference for the database" << dbname() << "with reference" << reference();
     return true;
 }
 
-QString DatabaseRef::dbname()
+QString DatabaseRef::dbname() const
 {
     return d->dbname;
 }
 
-void DatabaseRef::setDbname(QString dbname)
+void DatabaseRef::setDbname(const QString& dbname)
 {
     d->dbname = dbname;
 }
 
-QString DatabaseRef::type()
+QString DatabaseRef::type() const
 {
     return d->type;
 }
 
-void DatabaseRef::setType(QString type)
+void DatabaseRef::setType(const QString& type)
 {
     d->type = type;
 }
 
-QString DatabaseRef::reference()
+QString DatabaseRef::reference() const
 {
     return d->reference;
 }
 
-void DatabaseRef::setReference(QString reference)
+void DatabaseRef::setReference(const QString& reference)
 {
     d->reference = reference;
 }
diff --git a/src/acbf/AcbfDocument.h b/src/acbf/AcbfDocument.h
--- a/src/acbf/AcbfDocument.h
+++ b/src/acbf/AcbfDocument.h
@@ -22,6 +22,8 @@
 #ifndef ACBFDOCUMENT_H
 #define ACBFDOCUMENT_H
 
+#include <memory>
+
 #include <QObject>
 #include "acbf_export.h"
 
@@ -43,16 +45,16 @@
     QString toXml();
     bool fromXml(QString xmlDocument);
 
-    Metadata* metaData();
+    Metadata* metaData() const;
     Q_SIGNAL void metaDataChanged();
 
-    Body* body();
+    Body* body() const;
     // References* references();
-    Data* data();
+    Data* data() const;
     // Stylesheet* stylesheet();
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfDocument.cpp b/src/acbf/AcbfDocument.cpp
--- a/src/acbf/AcbfDocument.cpp
+++ b/src/acbf/AcbfDocument.cpp
@@ -51,19 +51,16 @@
     d->data = new Data(this);
 }
 
-Document::~Document()
-{
-    delete d;
-}
+Document::~Document() = default;
 
 QString Document::toXml()
 {
     QString output;
     QXmlStreamWriter writer(&output);
     writer.setAutoFormatting(true);
     writer.writeStartDocument();
-    writer.writeStartElement("ACBF");
-    writer.writeAttribute("xmlns", "http://www.fictionbook-lib.org/xml/acbf/1.0");
+    writer.writeStartElement(QStringLiteral("ACBF"));
+    writer.writeAttribute(QStringLiteral("xmlns"), QStringLiteral("http://www.fictionbook-lib.org/xml/acbf/1.0"));
     d->metaData->toXml(&writer);
     d->body->toXml(&writer);
     writer.writeEndElement();
@@ -77,23 +74,24 @@
     QXmlStreamReader xmlReader(xmlDocument);
     if(xmlReader.readNextStartElement())
     {
-        if(xmlReader.name() == "ACBF" && xmlReader.namespaceUri().startsWith("http://www.fictionbook-lib.org/xml/acbf/"))
+        if(xmlReader.name() == QStringLiteral("ACBF")
+            && xmlReader.namespaceUri().startsWith(QStringLiteral("http://www.fictionbook-lib.org/xml/acbf/")))
         {
             while(xmlReader.readNextStartElement())
             {
-                if(xmlReader.name() == "meta-data")
+                if(xmlReader.name() == QStringLiteral("meta-data"))
                 {
                     if(!d->metaData->fromXml(&xmlReader)) {
                         break;
                     }
                 }
-                else if(xmlReader.name() == "body")
+                else if(xmlReader.name() == QStringLiteral("body"))
                 {
                     if(!d->body->fromXml(&xmlReader)) {
                         break;
                     }
                 }
-                else if(xmlReader.name() == "data")
+                else if(xmlReader.name() == QStringLiteral("data"))
                 {
                     if(!d->data->fromXml(&xmlReader)) {
                         break;
@@ -118,17 +116,17 @@
     return !xmlReader.hasError();
 }
 
-Metadata * Document::metaData()
+Metadata * Document::metaData() const
 {
     return d->metaData;
 }
 
-Body * Document::body()
+Body * Document::body() const
 {
     return d->body;
 }
 
-Data * Document::data()
+Data * Document::data() const
 {
     return d->data;
 }
diff --git a/src/acbf/AcbfDocumentinfo.h b/src/acbf/AcbfDocumentinfo.h
--- a/src/acbf/AcbfDocumentinfo.h
+++ b/src/acbf/AcbfDocumentinfo.h
@@ -22,6 +22,8 @@
 #ifndef ACBFDOCUMENTINFO_H
 #define ACBFDOCUMENTINFO_H
 
+#include <memory>
+
 #include "AcbfMetadata.h"
 
 #include <QDate>
@@ -36,30 +38,30 @@
     explicit DocumentInfo(Metadata* parent = nullptr);
     ~DocumentInfo() override;
 
-    Metadata* metadata();
+    Metadata* metadata() const;
 
     void toXml(QXmlStreamWriter *writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QList<Author*> author();
+    QList<Author*> author() const;
     void addAuthor(Author* author);
     void removeAuthor(Author* author);
 
-    QDate creationDate();
-    void setCreationDate(QDate creationDate);
+    QDate creationDate() const;
+    void setCreationDate(const QDate& creationDate);
 
-    QStringList source();
-    void setSource(QStringList source);
+    QStringList source() const;
+    void setSource(const QStringList& source);
 
-    QString id();
-    void setId(QString id);
+    QString id() const;
+    void setId(const QString& id);
 
-    QString version();
-    void setVersion(QString version);
+    QString version() const;
+    void setVersion(const QString& version);
 
-    QStringList history();
-    void setHistory(QStringList history);
-    void addHistoryLine(QString historyLine);
+    QStringList history() const;
+    void setHistory(const QStringList& history);
+    void addHistoryLine(const QString& historyLine);
 private:
     class Private;
     Private* d;
diff --git a/src/acbf/AcbfDocumentinfo.cpp b/src/acbf/AcbfDocumentinfo.cpp
--- a/src/acbf/AcbfDocumentinfo.cpp
+++ b/src/acbf/AcbfDocumentinfo.cpp
@@ -46,47 +46,44 @@
     qRegisterMetaType<DocumentInfo*>("DocumentInfo*");
 }
 
-DocumentInfo::~DocumentInfo()
-{
-    delete d;
-}
+DocumentInfo::~DocumentInfo() = default;
 
-Metadata * DocumentInfo::metadata()
+Metadata * DocumentInfo::metadata() const
 {
     return qobject_cast<Metadata*>(parent());
 }
 
 void DocumentInfo::toXml(QXmlStreamWriter *writer)
 {
-    writer->writeStartElement("document-info");
+    writer->writeStartElement(QStringLiteral("document-info"));
 
     Q_FOREACH(Author* author, d->author) {
         author->toXml(writer);
     }
 
-    writer->writeStartElement("creation-date");
-    writer->writeCharacters(d->creationDate.toString("MMMM d yyyy"));
+    writer->writeStartElement(QStringLiteral("creation-date"));
+    writer->writeCharacters(d->creationDate.toString(QStringLiteral("MMMM d yyyy")));
     writer->writeEndElement();
 
-    writer->writeStartElement("source");
+    writer->writeStartElement(QStringLiteral("source"));
     Q_FOREACH(const QString& source, d->source) {
-        writer->writeStartElement("p");
+        writer->writeStartElement(QStringLiteral("p"));
         writer->writeCharacters(source);
         writer->writeEndElement();
     }
     writer->writeEndElement();
 
-    writer->writeStartElement("id");
+    writer->writeStartElement(QStringLiteral("id"));
     writer->writeCharacters(d->id);
     writer->writeEndElement();
 
-    writer->writeStartElement("version");
+    writer->writeStartElement(QStringLiteral("version"));
     writer->writeCharacters(d->version);
     writer->writeEndElement();
 
-    writer->writeStartElement("history");
+    writer->writeStartElement(QStringLiteral("history"));
     Q_FOREACH(const QString& history, d->history) {
-        writer->writeStartElement("p");
+        writer->writeStartElement(QStringLiteral("p"));
         writer->writeCharacters(history);
         writer->writeEndElement();
     }
@@ -99,47 +96,47 @@
 {
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "author")
+        if(xmlReader->name() == QStringLiteral("author"))
         {
             Author* newAuthor = new Author(metadata());
             if(!newAuthor->fromXml(xmlReader)) {
                 return false;
             }
             d->author.append(newAuthor);
         }
-        else if(xmlReader->name() == "creation-date")
+        else if(xmlReader->name() == QStringLiteral("creation-date"))
         {
-            QString date = xmlReader->attributes().value("value").toString();
+            QString date = xmlReader->attributes().value(QStringLiteral("value")).toString();
             if(date.isEmpty()) {
                 date = xmlReader->readElementText();
             } else {
                 xmlReader->skipCurrentElement();
             }
             setCreationDate(QDate::fromString(date));
         }
-        else if(xmlReader->name() == "source")
+        else if(xmlReader->name() == QStringLiteral("source"))
         {
             while(xmlReader->readNextStartElement()) {
-                if(xmlReader->name() == "p") {
+                if(xmlReader->name() == QStringLiteral("p")) {
                     d->source.append(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
                 }
                 else {
                     xmlReader->skipCurrentElement();
                 }
             }
         }
-        else if(xmlReader->name() == "id")
+        else if(xmlReader->name() == QStringLiteral("id"))
         {
             setId(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "version")
+        else if(xmlReader->name() == QStringLiteral("version"))
         {
             setVersion(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "history")
+        else if(xmlReader->name() == QStringLiteral("history"))
         {
             while(xmlReader->readNextStartElement()) {
-                if(xmlReader->name() == "p") {
+                if(xmlReader->name() == QStringLiteral("p")) {
                     d->history.append(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
                 }
                 else {
@@ -160,7 +157,7 @@
     return !xmlReader->hasError();
 }
 
-QList<Author *> DocumentInfo::author()
+QList<Author *> DocumentInfo::author() const
 {
     return d->author;
 }
@@ -175,57 +172,57 @@
     d->author.removeAll(author);
 }
 
-QDate DocumentInfo::creationDate()
+QDate DocumentInfo::creationDate() const
 {
     return d->creationDate;
 }
 
-void DocumentInfo::setCreationDate(QDate creationDate)
+void DocumentInfo::setCreationDate(const QDate& creationDate)
 {
     d->creationDate = creationDate;
 }
 
-QStringList DocumentInfo::source()
+QStringList DocumentInfo::source() const
 {
     return d->source;
 }
 
-void DocumentInfo::setSource(QStringList source)
+void DocumentInfo::setSource(const QStringList& source)
 {
     d->source = source;
 }
 
-QString DocumentInfo::id()
+QString DocumentInfo::id() const
 {
     return d->id;
 }
 
-void DocumentInfo::setId(QString id)
+void DocumentInfo::setId(const QString& id)
 {
     d->id = id;
 }
 
-QString DocumentInfo::version()
+QString DocumentInfo::version() const
 {
     return d->version;
 }
 
-void DocumentInfo::setVersion(QString version)
+void DocumentInfo::setVersion(const QString& version)
 {
     d->version = version;
 }
 
-QStringList DocumentInfo::history()
+QStringList DocumentInfo::history() const
 {
     return d->history;
 }
 
-void DocumentInfo::setHistory(QStringList history)
+void DocumentInfo::setHistory(const QStringList& history)
 {
     d->history = history;
 }
 
-void DocumentInfo::addHistoryLine(QString historyLine)
+void DocumentInfo::addHistoryLine(const QString& historyLine)
 {
     d->history.append(historyLine);
 }
diff --git a/src/acbf/AcbfLanguage.h b/src/acbf/AcbfLanguage.h
--- a/src/acbf/AcbfLanguage.h
+++ b/src/acbf/AcbfLanguage.h
@@ -22,6 +22,8 @@
 #ifndef ACBFLANGUAGEINFO_H
 #define ACBFLANGUAGEINFO_H
 
+#include <memory>
+
 #include "AcbfBookinfo.h"
 
 namespace AdvancedComicBookFormat
@@ -38,14 +40,14 @@
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    void setLanguage(QString language);
-    QString language();
+    void setLanguage(const QString& language);
+    QString language() const;
 
     void setShow(bool show);
-    bool show();
+    bool show() const;
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfLanguage.cpp b/src/acbf/AcbfLanguage.cpp
--- a/src/acbf/AcbfLanguage.cpp
+++ b/src/acbf/AcbfLanguage.cpp
@@ -42,34 +42,31 @@
 {
 }
 
-Language::~Language()
-{
-    delete d;
-}
+Language::~Language() = default;
 
 void Language::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("text-layer");
-    writer->writeAttribute("lang", d->language);
-    writer->writeAttribute("show", d->show ? "true" : "false");
+    writer->writeStartElement(QStringLiteral("text-layer"));
+    writer->writeAttribute(QStringLiteral("lang"), d->language);
+    writer->writeAttribute(QStringLiteral("show"), d->show ? QStringLiteral("true") : QStringLiteral("false"));
     writer->writeEndElement();
 }
 
 bool Language::fromXml(QXmlStreamReader *xmlReader)
 {
-    setShow(xmlReader->attributes().value("show").toString().toLower() == "true");
-    setLanguage(xmlReader->attributes().value("lang").toString());
+    setShow(xmlReader->attributes().value(QStringLiteral("show")).toString().toLower() == QStringLiteral("true"));
+    setLanguage(xmlReader->attributes().value(QStringLiteral("lang")).toString());
     xmlReader->skipCurrentElement();
     qDebug() << Q_FUNC_INFO << "Created language" << language();
     return true;
 }
 
-void Language::setLanguage(QString language)
+void Language::setLanguage(const QString& language)
 {
     d->language = language;
 }
 
-QString Language::language()
+QString Language::language() const
 {
     return d->language;
 }
@@ -79,7 +76,7 @@
     d->show = show;
 }
 
-bool Language::show()
+bool Language::show() const
 {
     return d->show;
 }
diff --git a/src/acbf/AcbfMetadata.h b/src/acbf/AcbfMetadata.h
--- a/src/acbf/AcbfMetadata.h
+++ b/src/acbf/AcbfMetadata.h
@@ -22,6 +22,8 @@
 #ifndef ACBFMETADATA_H
 #define ACBFMETADATA_H
 
+#include <memory>
+
 #include "AcbfDocument.h"
 
 class QXmlStreamWriter;
@@ -38,18 +40,18 @@
     explicit Metadata(Document* parent = nullptr);
     ~Metadata() override;
 
-    Document* document();
+    Document* document() const;
 
     void toXml(QXmlStreamWriter *writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    BookInfo* bookInfo();
+    BookInfo* bookInfo() const;
     Q_SIGNAL void bookInfoChanged();
-    PublishInfo* publishInfo();
-    DocumentInfo* documentInfo();
+    PublishInfo* publishInfo() const;
+    DocumentInfo* documentInfo() const;
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfMetadata.cpp b/src/acbf/AcbfMetadata.cpp
--- a/src/acbf/AcbfMetadata.cpp
+++ b/src/acbf/AcbfMetadata.cpp
@@ -52,19 +52,16 @@
     d->documentInfo = new DocumentInfo(this);
 }
 
-Metadata::~Metadata()
-{
-    delete d;
-}
+Metadata::~Metadata() = default;
 
-Document * Metadata::document()
+Document * Metadata::document() const
 {
     return qobject_cast<Document*>(parent());
 }
 
 void Metadata::toXml(QXmlStreamWriter *writer)
 {
-    writer->writeStartElement("meta-data");
+    writer->writeStartElement(QStringLiteral("meta-data"));
     d->bookInfo->toXml(writer);
     d->publishInfo->toXml(writer);
     d->documentInfo->toXml(writer);
@@ -75,19 +72,19 @@
 {
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "book-info")
+        if(xmlReader->name() == QStringLiteral("book-info"))
         {
             if(!d->bookInfo->fromXml(xmlReader)) {
                 return false;
             }
         }
-        else if(xmlReader->name() == "publish-info")
+        else if(xmlReader->name() == QStringLiteral("publish-info"))
         {
             if(!d->publishInfo->fromXml(xmlReader)) {
                 return false;
             }
         }
-        else if(xmlReader->name() == "document-info")
+        else if(xmlReader->name() == QStringLiteral("document-info"))
         {
             if(!d->documentInfo->fromXml(xmlReader)) {
                 return false;
@@ -106,17 +103,17 @@
     return !xmlReader->hasError();
 }
 
-DocumentInfo * Metadata::documentInfo()
+DocumentInfo * Metadata::documentInfo() const
 {
     return d->documentInfo;
 }
 
-BookInfo * Metadata::bookInfo()
+BookInfo * Metadata::bookInfo() const
 {
     return d->bookInfo;
 }
 
-PublishInfo * Metadata::publishInfo()
+PublishInfo * Metadata::publishInfo() const
 {
     return d->publishInfo;
 }
diff --git a/src/acbf/AcbfPage.h b/src/acbf/AcbfPage.h
--- a/src/acbf/AcbfPage.h
+++ b/src/acbf/AcbfPage.h
@@ -42,46 +42,48 @@
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString bgcolor();
-    void setBgcolor(QString newColor = "");
+    QString bgcolor() const;
+    void setBgcolor(const QString& newColor = QString());
 
-    QString transition();
-    void setTransition(QString transition);
+    QString transition() const;
+    void setTransition(const QString& transition);
     static QStringList availableTransitions();
 
-    QStringList titleForAllLanguages();
-    QString title(QString language = "");
-    void setTitle(QString title, QString language = "");
+    QStringList titleForAllLanguages() const;
+    QString title(const QString& language = QString()) const;
+    void setTitle(const QString& title, const QString& language = QString());
 
-    QString imageHref();
-    void setImageHref(QString imageHref);
+    QString imageHref() const;
+    void setImageHref(const QString& imageHref);
 
-    QList<Textlayer*> textLayersForAllLanguages();
-    Textlayer* textLayer(QString language = "");
+    QList<Textlayer*> textLayersForAllLanguages() const;
+    Textlayer* textLayer(const QString& language = QString()) const;
     // Setting the textlayer for a language to null removes that language (as with other translated entries, though this one not being text warranted a comment)
-    void setTextLayer(Textlayer* textlayer, QString language = "");
+    void setTextLayer(Textlayer* textlayer, const QString& language = "");
+
+    QList<Frame*> frames() const;
+    Frame* frame(int index) const;
+    int frameIndex(Frame* frame) const;
 
-    QList<Frame*> frames();
-    Frame* frame(int index);
-    int frameIndex(Frame* frame);
     // If afterIndex is larger than zero, the insertion will happen at that index
     void addFrame(Frame* frame, int index = -1);
     void removeFrame(Frame* frame);
     bool swapFrames(Frame* swapThis, Frame* withThis);
 
-    QList<Jump*> jumps();
-    Jump* jump(int index);
-    int jumpIndex(Jump* jump);
+    QList<Jump*> jumps() const;
+    Jump* jump(int index) const;
+    int jumpIndex(Jump* jump) const;
+
     // If afterIndex is larger than zero, the insertion will happen at that index
     void addJump(Jump* jump, int index = -1);
     void removeJump(Jump* jump);
     bool swapJumps(Jump* swapThis, Jump* withThis);
 
-    bool isCoverPage();
+    bool isCoverPage() const;
     void setIsCoverPage(bool isCoverPage = false);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfPage.cpp b/src/acbf/AcbfPage.cpp
--- a/src/acbf/AcbfPage.cpp
+++ b/src/acbf/AcbfPage.cpp
@@ -50,38 +50,35 @@
 {
 }
 
-Page::~Page()
-{
-    delete d;
-}
+Page::~Page() = default;
 
 void Page::toXml(QXmlStreamWriter* writer)
 {
     if(d->isCoverPage) {
-        writer->writeStartElement("coverpage");
+        writer->writeStartElement(QStringLiteral("coverpage"));
     }
     else {
-        writer->writeStartElement("page");
+        writer->writeStartElement(QStringLiteral("page"));
     }
 
     if(!d->bgcolor.isEmpty()) {
-        writer->writeAttribute("bgcolor", d->bgcolor);
+        writer->writeAttribute(QStringLiteral("bgcolor"), d->bgcolor);
     }
     if(!d->transition.isEmpty()) {
-        writer->writeAttribute("transition", d->transition);
+        writer->writeAttribute(QStringLiteral("transition"), d->transition);
     }
 
     QHashIterator<QString, QString> titles(d->title);
     while(titles.hasNext()) {
         titles.next();
-        writer->writeStartElement("title");
-        writer->writeAttribute("lang", titles.key());
+        writer->writeStartElement(QStringLiteral("title"));
+        writer->writeAttribute(QStringLiteral("lang"), titles.key());
         writer->writeCharacters(titles.value());
         writer->writeEndElement();
     }
 
-    writer->writeStartElement("image");
-    writer->writeAttribute("href", d->imageHref);
+    writer->writeStartElement(QStringLiteral("image"));
+    writer->writeAttribute(QStringLiteral("href"), d->imageHref);
     writer->writeEndElement();
 
     Q_FOREACH(Textlayer* layer, d->textLayers.values()) {
@@ -101,20 +98,20 @@
 
 bool Page::fromXml(QXmlStreamReader *xmlReader)
 {
-    setBgcolor(xmlReader->attributes().value("bgcolor").toString());
-    setTransition(xmlReader->attributes().value("transition").toString());
+    setBgcolor(xmlReader->attributes().value(QStringLiteral("bgcolor")).toString());
+    setTransition(xmlReader->attributes().value(QStringLiteral("transition")).toString());
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "title")
+        if(xmlReader->name() == QStringLiteral("title"))
         {
-            d->title[xmlReader->attributes().value("lang").toString()] = xmlReader->readElementText();
+            d->title[xmlReader->attributes().value(QStringLiteral("lang")).toString()] = xmlReader->readElementText();
         }
-        else if(xmlReader->name() == "image")
+        else if(xmlReader->name() == QStringLiteral("image"))
         {
-            setImageHref(xmlReader->attributes().value("href").toString());
+            setImageHref(xmlReader->attributes().value(QStringLiteral("href")).toString());
             xmlReader->skipCurrentElement();
         }
-        else if(xmlReader->name() == "text-layer")
+        else if(xmlReader->name() == QStringLiteral("text-layer"))
         {
             Textlayer* newLayer = new Textlayer(this);
             if(!newLayer->fromXml(xmlReader)) {
@@ -151,48 +148,48 @@
     return !xmlReader->hasError();
 }
 
-QString Page::bgcolor()
+QString Page::bgcolor() const
 {
     return d->bgcolor;
 }
 
-void Page::setBgcolor(QString newColor)
+void Page::setBgcolor(const QString& newColor)
 {
     d->bgcolor = newColor;
 }
 
-QString Page::transition()
+QString Page::transition() const
 {
     return d->transition;
 }
 
-void Page::setTransition(QString transition)
+void Page::setTransition(const QString& transition)
 {
     d->transition = transition;
 }
 
 QStringList Page::availableTransitions()
 {
-    QStringList transitions;
-    transitions << "fade"; // (old page fades out into background, then new page fades in)
-    transitions << "blend"; // (new page blends in the image while old page blends out)
-    transitions << "scroll_right"; // (screen scrolls to the right to a new page; reversed behavior applies when moving to previous page)
-    transitions << "scroll_down"; // (screen scrolls down to a new page; reversed behavior applies when moving to previous page)
-    transitions << "none"; // (no transition animation happens)
-    return transitions;
+    return {
+        QStringLiteral("fade"), // (old page fades out into background, then new page fades in)
+        QStringLiteral("blend"), // (new page blends in the image while old page blends out)
+        QStringLiteral("scroll_right"), // (screen scrolls to the right to a new page; reversed behavior applies when moving to previous page)
+        QStringLiteral("scroll_down"), // (screen scrolls down to a new page; reversed behavior applies when moving to previous page)
+        QStringLiteral("none") // (no transition animation happens)
+    };
 }
 
-QStringList Page::titleForAllLanguages()
+QStringList Page::titleForAllLanguages() const
 {
     return d->title.values();
 }
 
-QString Page::title(QString language)
+QString Page::title(const QString& language) const
 {
     return d->title.value(language);
 }
 
-void Page::setTitle(QString title, QString language)
+void Page::setTitle(const QString& title, const QString& language)
 {
     if(title.isEmpty())
     {
@@ -204,27 +201,27 @@
     }
 }
 
-QString Page::imageHref()
+QString Page::imageHref() const
 {
     return d->imageHref;
 }
 
-void Page::setImageHref(QString imageHref)
+void Page::setImageHref(const QString& imageHref)
 {
     d->imageHref = imageHref;
 }
 
-QList<Textlayer *> Page::textLayersForAllLanguages()
+QList<Textlayer *> Page::textLayersForAllLanguages() const
 {
     return d->textLayers.values();
 }
 
-Textlayer * Page::textLayer(QString language)
+Textlayer * Page::textLayer(const QString& language) const
 {
     return d->textLayers.value(language);
 }
 
-void Page::setTextLayer(Textlayer* textlayer, QString language)
+void Page::setTextLayer(Textlayer* textlayer, const QString& language)
 {
     if(textlayer)
     {
@@ -236,17 +233,17 @@
     }
 }
 
-QList<Frame *> Page::frames()
+QList<Frame *> Page::frames() const
 {
     return d->frames;
 }
 
-Frame * Page::frame(int index)
+Frame * Page::frame(int index) const
 {
     return d->frames.at(index);
 }
 
-int Page::frameIndex(Frame* frame)
+int Page::frameIndex(Frame* frame) const
 {
     return d->frames.indexOf(frame);
 }
@@ -277,17 +274,17 @@
     return false;
 }
 
-QList<Jump *> Page::jumps()
+QList<Jump *> Page::jumps() const
 {
     return d->jumps;
 }
 
-Jump * Page::jump(int index)
+Jump * Page::jump(int index) const
 {
     return d->jumps.at(index);
 }
 
-int Page::jumpIndex(Jump* jump)
+int Page::jumpIndex(Jump* jump) const
 {
     return d->jumps.indexOf(jump);
 }
@@ -318,7 +315,7 @@
     return false;
 }
 
-bool Page::isCoverPage()
+bool Page::isCoverPage() const
 {
     return d->isCoverPage;
 }
diff --git a/src/acbf/AcbfPublishinfo.h b/src/acbf/AcbfPublishinfo.h
--- a/src/acbf/AcbfPublishinfo.h
+++ b/src/acbf/AcbfPublishinfo.h
@@ -22,6 +22,8 @@
 #ifndef ACBFPUBLISHINFO_H
 #define ACBFPUBLISHINFO_H
 
+#include <memory>
+
 #include "AcbfMetadata.h"
 
 #include <QDate>
@@ -38,23 +40,23 @@
     void toXml(QXmlStreamWriter *writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString publisher();
-    void setPublisher(QString publisher);
+    QString publisher() const;
+    void setPublisher(const QString& publisher);
 
-    QDate publishDate();
-    void setPublishDate(QDate publishDate);
+    QDate publishDate() const;
+    void setPublishDate(const QDate& publishDate);
 
-    QString city();
-    void setCity(QString city = "");
+    QString city() const;
+    void setCity(const QString& city = QString());
 
-    QString isbn();
-    void setIsbn(QString isbn = "");
+    QString isbn() const;
+    void setIsbn(const QString& isbn = QString());
 
-    QString license();
-    void setLicense(QString license = "");
+    QString license() const;
+    void setLicense(const QString& license = QString());
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfPublishinfo.cpp b/src/acbf/AcbfPublishinfo.cpp
--- a/src/acbf/AcbfPublishinfo.cpp
+++ b/src/acbf/AcbfPublishinfo.cpp
@@ -45,33 +45,30 @@
     qRegisterMetaType<PublishInfo*>("PublishInfo*");
 }
 
-PublishInfo::~PublishInfo()
-{
-    delete d;
-}
+PublishInfo::~PublishInfo() = default;
 
 void PublishInfo::toXml(QXmlStreamWriter *writer)
 {
-    writer->writeStartElement("publish-info");
+    writer->writeStartElement(QStringLiteral("publish-info"));
 
-    writer->writeStartElement("publisher");
+    writer->writeStartElement(QStringLiteral("publisher"));
     writer->writeCharacters(d->publisher);
     writer->writeEndElement();
 
-    writer->writeStartElement("publish-date");
-    writer->writeAttribute("value", d->publishDate.toString("YYYY-MM-dd"));
-    writer->writeCharacters(d->publishDate.toString("MMMM d yyyy"));
+    writer->writeStartElement(QStringLiteral("publish-date"));
+    writer->writeAttribute(QStringLiteral("value"), d->publishDate.toString(QStringLiteral("YYYY-MM-dd")));
+    writer->writeCharacters(d->publishDate.toString(QStringLiteral("MMMM d yyyy")));
     writer->writeEndElement();
 
-    writer->writeStartElement("city");
+    writer->writeStartElement(QStringLiteral("city"));
     writer->writeCharacters(d->city);
     writer->writeEndElement();
 
-    writer->writeStartElement("isbn");
+    writer->writeStartElement(QStringLiteral("isbn"));
     writer->writeCharacters(d->isbn);
     writer->writeEndElement();
 
-    writer->writeStartElement("license");
+    writer->writeStartElement(QStringLiteral("license"));
     writer->writeCharacters(d->license);
     writer->writeEndElement();
 
@@ -82,29 +79,29 @@
 {
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "publisher")
+        if(xmlReader->name() == QStringLiteral("publisher"))
         {
             setPublisher(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "publish-date")
+        else if(xmlReader->name() == QStringLiteral("publish-date"))
         {
-            QString date = xmlReader->attributes().value("value").toString();
+            QString date = xmlReader->attributes().value(QStringLiteral("value")).toString();
             if(date.isEmpty()) {
                 date = xmlReader->readElementText();
             } else {
                 xmlReader->skipCurrentElement();
             }
             setPublishDate(QDate::fromString(date));
         }
-        else if(xmlReader->name() == "city")
+        else if(xmlReader->name() == QStringLiteral("city"))
         {
             setCity(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "isbn")
+        else if(xmlReader->name() == QStringLiteral("isbn"))
         {
             setIsbn(xmlReader->readElementText());
         }
-        else if(xmlReader->name() == "license")
+        else if(xmlReader->name() == QStringLiteral("license"))
         {
             setLicense(xmlReader->readElementText());
         }
@@ -121,52 +118,52 @@
     return !xmlReader->hasError();
 }
 
-QString PublishInfo::publisher()
+QString PublishInfo::publisher() const
 {
     return d->publisher;
 }
 
-void PublishInfo::setPublisher(QString publisher)
+void PublishInfo::setPublisher(const QString& publisher)
 {
     d->publisher = publisher;
 }
 
-QDate PublishInfo::publishDate()
+QDate PublishInfo::publishDate() const
 {
     return d->publishDate;
 }
 
-void PublishInfo::setPublishDate(QDate publishDate)
+void PublishInfo::setPublishDate(const QDate& publishDate)
 {
     d->publishDate = publishDate;
 }
 
-QString PublishInfo::city()
+QString PublishInfo::city() const
 {
     return d->city;
 }
 
-void PublishInfo::setCity(QString city)
+void PublishInfo::setCity(const QString& city)
 {
     d->city = city;
 }
 
-QString PublishInfo::isbn()
+QString PublishInfo::isbn() const
 {
     return d->isbn;
 }
 
-void PublishInfo::setIsbn(QString isbn)
+void PublishInfo::setIsbn(const QString& isbn)
 {
     d->isbn = isbn;
 }
 
-QString PublishInfo::license()
+QString PublishInfo::license() const
 {
     return d->license;
 }
 
-void PublishInfo::setLicense(QString license)
+void PublishInfo::setLicense(const QString& license)
 {
     d->license = license;
 }
diff --git a/src/acbf/AcbfSequence.h b/src/acbf/AcbfSequence.h
--- a/src/acbf/AcbfSequence.h
+++ b/src/acbf/AcbfSequence.h
@@ -22,6 +22,8 @@
 #ifndef ACBFSEQUENCE_H
 #define ACBFSEQUENCE_H
 
+#include <memory>
+
 #include "AcbfBookinfo.h"
 
 namespace AdvancedComicBookFormat
@@ -36,18 +38,18 @@
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString title();
-    void setTitle(QString title);
+    QString title() const;
+    void setTitle(const QString& title);
 
     // Optional attribute - if set to 0, this is not saved
-    int volume();
+    int volume() const;
     void setVolume(int volume = 0);
 
-    int number();
+    int number() const;
     void setNumber(int number);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfSequence.cpp b/src/acbf/AcbfSequence.cpp
--- a/src/acbf/AcbfSequence.cpp
+++ b/src/acbf/AcbfSequence.cpp
@@ -44,40 +44,37 @@
 {
 }
 
-Sequence::~Sequence()
-{
-    delete d;
-}
+Sequence::~Sequence() = default;
 
 void Sequence::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("sequence");
-    writer->writeAttribute("title", d->title);
-    writer->writeAttribute("volume", QString::number(d->volume));
+    writer->writeStartElement(QStringLiteral("sequence"));
+    writer->writeAttribute(QStringLiteral("title"), d->title);
+    writer->writeAttribute(QStringLiteral("volume"), QString::number(d->volume));
     writer->writeCharacters(QString::number(d->number));
     writer->writeEndElement();
 }
 
 bool Sequence::fromXml(QXmlStreamReader *xmlReader)
 {
-    setVolume(xmlReader->attributes().value("volume").toInt());
-    setTitle(xmlReader->attributes().value("title").toString());
+    setVolume(xmlReader->attributes().value(QStringLiteral("volume")).toInt());
+    setTitle(xmlReader->attributes().value(QStringLiteral("title")).toString());
     setNumber(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements).toInt());
     qDebug() << Q_FUNC_INFO << "Created sequence entry, which places this book as number" << number() << "in the series" << title();
     return true;
 }
 
-QString Sequence::title()
+QString Sequence::title() const
 {
     return d->title;
 }
 
-void Sequence::setTitle(QString title)
+void Sequence::setTitle(const QString& title)
 {
     d->title = title;
 }
 
-int Sequence::volume()
+int Sequence::volume() const
 {
     return d->volume;
 }
@@ -87,7 +84,7 @@
     d->volume = volume;
 }
 
-int Sequence::number()
+int Sequence::number() const
 {
     return d->number;
 }
diff --git a/src/acbf/AcbfTextarea.h b/src/acbf/AcbfTextarea.h
--- a/src/acbf/AcbfTextarea.h
+++ b/src/acbf/AcbfTextarea.h
@@ -22,6 +22,8 @@
 #ifndef ACBFTEXTAREA_H
 #define ACBFTEXTAREA_H
 
+#include <memory>
+
 #include "AcbfTextlayer.h"
 
 #include <QPoint>
@@ -35,40 +37,42 @@
     explicit Textarea(Textlayer* parent = nullptr);
     ~Textarea() override;
 
+    static QStringList availableTypes();
+
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QList<QPoint> points();
-    QPoint point(int index);
-    int pointIndex(QPoint point);
+    QList<QPoint> points() const;
+    QPoint point(int index) const;
+    int pointIndex(const QPoint& point) const;
+
     // If afterIndex is larger than zero, the insertion will happen at that index
-    void addPoint(QPoint point, int index = -1);
-    void removePoint(QPoint point);
-    bool swapPoints(QPoint swapThis, QPoint withThis);
+    void addPoint(const QPoint& point, int index = -1);
+    void removePoint(const QPoint& point);
+    bool swapPoints(const QPoint& swapThis, const QPoint& withThis);
 
-    QString bgcolor();
-    void setBgcolor(QString newColor = "");
+    QString bgcolor() const;
+    void setBgcolor(const QString& newColor = QString());
 
-    int textRotation();
+    int textRotation() const;
     void setTextRotation(int rotation = 0);
 
-    QString type();
-    void setType(QString type = "speech");
-    static QStringList availableTypes();
+    QString type() const;
+    void setType(const QString& type = QStringLiteral("speech"));
 
-    bool inverted();
+    bool inverted() const;
     void setInverted(bool inverted = false);
 
-    bool transparent();
+    bool transparent() const;
     void setTransparent(bool transparent = false);
 
-    QStringList paragraphs();
+    QStringList paragraphs() const;
     // Allowed sub-elements: strong, emphasis, strikethrough, sub, sup, a (with mandatory href attribute only)
     // Deprecated sub-elements (superceded by...): code (type option code), inverted (textarea option inverted)
-    void setParagraphs(QStringList paragraphs);
+    void setParagraphs(const QStringList& paragraphs);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfTextarea.cpp b/src/acbf/AcbfTextarea.cpp
--- a/src/acbf/AcbfTextarea.cpp
+++ b/src/acbf/AcbfTextarea.cpp
@@ -47,41 +47,38 @@
 {
 }
 
-Textarea::~Textarea()
-{
-    delete d;
-}
+Textarea::~Textarea() = default;
 
 void Textarea::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("text-area");
+    writer->writeStartElement(QStringLiteral("text-area"));
 
     QStringList points;
     Q_FOREACH(const QPoint& point, d->points) {
-        points << QString("%1,%2").arg(QString::number(point.x())).arg(QString::number(point.y()));
+        points << QStringLiteral("%1,%2").arg(QString::number(point.x())).arg(QString::number(point.y()));
     }
-    writer->writeAttribute("points", points.join(' '));
+    writer->writeAttribute(QStringLiteral("points"), points.join(' '));
 
     if(!d->bgcolor.isEmpty()) {
-        writer->writeAttribute("bgcolor", d->bgcolor);
+        writer->writeAttribute(QStringLiteral("bgcolor"), d->bgcolor);
     }
     if(d->textRotation != 0) {
-        writer->writeAttribute("text-rotation", QString::number(d->textRotation));
+        writer->writeAttribute(QStringLiteral("text-rotation"), QString::number(d->textRotation));
     }
     if(!d->type.isEmpty()) {
-        writer->writeAttribute("type", d->type);
+        writer->writeAttribute(QStringLiteral("type"), d->type);
     }
     if(d->inverted) {
         // because the default is false, no need to write it otherwise...
-        writer->writeAttribute("inverted", "true");
+        writer->writeAttribute(QStringLiteral("inverted"), QStringLiteral("true"));
     }
     if(d->transparent) {
         // because the default is false, no need to write it otherwise...
-        writer->writeAttribute("transparent", "true");
+        writer->writeAttribute(QStringLiteral("transparent"), QStringLiteral("true"));
     }
 
     Q_FOREACH(const QString& paragraph, d->paragraphs) {
-        writer->writeStartElement("p");
+        writer->writeStartElement(QStringLiteral("p"));
         writer->writeCharacters(paragraph);
         writer->writeEndElement();
     }
@@ -91,13 +88,13 @@
 
 bool Textarea::fromXml(QXmlStreamReader *xmlReader)
 {
-    setBgcolor(xmlReader->attributes().value("bgcolor").toString());
-    setTextRotation(xmlReader->attributes().value("text-rotation").toInt());
-    setType(xmlReader->attributes().value("type").toString());
-    setInverted(xmlReader->attributes().value("inverted").toString().toLower() == "true");
-    setTransparent(xmlReader->attributes().value("transparent").toString().toLower() == "true");
+    setBgcolor(xmlReader->attributes().value(QStringLiteral("bgcolor")).toString());
+    setTextRotation(xmlReader->attributes().value(QStringLiteral("text-rotation")).toInt());
+    setType(xmlReader->attributes().value(QStringLiteral("type")).toString());
+    setInverted(xmlReader->attributes().value(QStringLiteral("inverted")).toString().toLower() == QStringLiteral("true"));
+    setTransparent(xmlReader->attributes().value(QStringLiteral("transparent")).toString().toLower() == QStringLiteral("true"));
 
-    QStringList points = xmlReader->attributes().value("points").toString().split(' ');
+    QStringList points = xmlReader->attributes().value(QStringLiteral("points")).toString().split(' ');
     Q_FOREACH(const QString& point, points) {
         QStringList elements = point.split(',');
         if(elements.length() == 2)
@@ -113,7 +110,7 @@
 
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "p")
+        if(xmlReader->name() == QStringLiteral("p"))
         {
             d->paragraphs.append(xmlReader->readElementText(QXmlStreamReader::IncludeChildElements));
         }
@@ -130,22 +127,22 @@
     return !xmlReader->hasError();
 }
 
-QList<QPoint> Textarea::points()
+QList<QPoint> Textarea::points() const
 {
     return d->points;
 }
 
-QPoint Textarea::point(int index)
+QPoint Textarea::point(int index) const
 {
     return d->points.at(index);
 }
 
-int Textarea::pointIndex(QPoint point)
+int Textarea::pointIndex(const QPoint& point) const
 {
     return d->points.indexOf(point);
 }
 
-void Textarea::addPoint(QPoint point, int index)
+void Textarea::addPoint(const QPoint& point, int index)
 {
     if(index > -1 && d->points.count() < index) {
         d->points.insert(index, point);
@@ -155,12 +152,12 @@
     }
 }
 
-void Textarea::removePoint(QPoint point)
+void Textarea::removePoint(const QPoint& point)
 {
     d->points.removeAll(point);
 }
 
-bool Textarea::swapPoints(QPoint swapThis, QPoint withThis)
+bool Textarea::swapPoints(const QPoint& swapThis, const QPoint& withThis)
 {
     int index1 = d->points.indexOf(swapThis);
     int index2 = d->points.indexOf(withThis);
@@ -171,12 +168,12 @@
     return false;
 }
 
-QString Textarea::bgcolor()
+QString Textarea::bgcolor() const
 {
     return d->bgcolor;
 }
 
-void Textarea::setBgcolor(QString newColor)
+void Textarea::setBgcolor(const QString& newColor)
 {
     d->bgcolor = newColor;
 }
@@ -186,37 +183,37 @@
     d->textRotation = rotation;
 }
 
-int Textarea::textRotation()
+int Textarea::textRotation() const
 {
     return d->textRotation;
 }
 
-QString Textarea::type()
+QString Textarea::type() const
 {
     return d->type.isEmpty() ? "speech" : d->type;
 }
 
-void Textarea::setType(QString type)
+void Textarea::setType(const QString& type)
 {
     d->type = type;
 }
 
 QStringList Textarea::availableTypes()
 {
-    QStringList types;
-    types << "speech"; // (character is speaking, text is centered)
-    types << "commentary"; // (accompanying commentary, text is aligned to left)
-    types << "formal"; // (text alignment is - justify)
-    types << "letter"; // (rendered in handwriting font)
-    types << "code"; // (rendered in monospace font)
-    types << "heading"; // (e.g. chapter title)
-    types << "audio"; // (speech emanating from an audio device, e.g., television or radio speaker, telephone, walkie-talkie, etc.)
-    types << "thought";
-    types << "sign"; // (any kind of sign/writing, text is centered)
-    return types;
+    return {
+        QStringLiteral("speech"), // (character is speaking, text is centered)
+        QStringLiteral("commentary"), // (accompanying commentary, text is aligned to left)
+        QStringLiteral("formal"), // (text alignment is - justify)
+        QStringLiteral("letter"), // (rendered in handwriting font)
+        QStringLiteral("code"), // (rendered in monospace font)
+        QStringLiteral("heading"), // (e.g. chapter title)
+        QStringLiteral("audio"), // (speech emanating from an audio device, e.g., television or radio speaker, telephone, walkie-talkie, etc.)
+        QStringLiteral("thought"),
+        QStringLiteral("sign"), // (any kind of sign/writing, text is centered)
+    };
 }
 
-bool Textarea::inverted()
+bool Textarea::inverted() const
 {
     return d->inverted;
 }
@@ -226,7 +223,7 @@
     d->inverted = inverted;
 }
 
-bool Textarea::transparent()
+bool Textarea::transparent() const
 {
     return d->transparent;
 }
@@ -236,12 +233,12 @@
     d->transparent = transparent;
 }
 
-QStringList Textarea::paragraphs()
+QStringList Textarea::paragraphs() const
 {
     return d->paragraphs;
 }
 
-void Textarea::setParagraphs(QStringList paragraphs)
+void Textarea::setParagraphs(const QStringList& paragraphs)
 {
     d->paragraphs = paragraphs;
 }
diff --git a/src/acbf/AcbfTextlayer.h b/src/acbf/AcbfTextlayer.h
--- a/src/acbf/AcbfTextlayer.h
+++ b/src/acbf/AcbfTextlayer.h
@@ -22,6 +22,8 @@
 #ifndef ACBFTEXTLAYER_H
 #define ACBFTEXTLAYER_H
 
+#include <memory>
+
 #include "AcbfPage.h"
 
 namespace AdvancedComicBookFormat
@@ -37,22 +39,23 @@
     void toXml(QXmlStreamWriter* writer);
     bool fromXml(QXmlStreamReader *xmlReader);
 
-    QString language();
-    void setLanguage(QString language);
+    QString language() const;
+    void setLanguage(const QString& language);
+
+    QString bgcolor() const;
+    void setBgcolor(const QString& newColor = QString());
 
-    QString bgcolor();
-    void setBgcolor(QString newColor = "");
+    QList<Textarea*> textareas() const;
+    Textarea* textarea(int index) const;
+    int textareaIndex(Textarea* textarea) const;
 
-    QList<Textarea*> textareas();
-    Textarea* textarea(int index);
-    int textareaIndex(Textarea* textarea);
     // If afterIndex is larger than zero, the insertion will happen at that index
     void addTextarea(Textarea* textarea, int index = -1);
     void removeTextarea(Textarea* textarea);
     bool swapTextareas(Textarea* swapThis, Textarea* withThis);
 private:
     class Private;
-    Private* d;
+    std::unique_ptr<Private> d;
 };
 }
 
diff --git a/src/acbf/AcbfTextlayer.cpp b/src/acbf/AcbfTextlayer.cpp
--- a/src/acbf/AcbfTextlayer.cpp
+++ b/src/acbf/AcbfTextlayer.cpp
@@ -43,19 +43,16 @@
 {
 }
 
-Textlayer::~Textlayer()
-{
-    delete d;
-}
+Textlayer::~Textlayer() = default;
 
 void Textlayer::toXml(QXmlStreamWriter* writer)
 {
-    writer->writeStartElement("text-layer");
+    writer->writeStartElement(QStringLiteral("text-layer"));
     if(!d->language.isEmpty()) {
-        writer->writeAttribute("lang", d->language);
+        writer->writeAttribute(QStringLiteral("lang"), d->language);
     }
     if(!d->bgcolor.isEmpty()) {
-        writer->writeAttribute("bgcolor", d->bgcolor);
+        writer->writeAttribute(QStringLiteral("bgcolor"), d->bgcolor);
     }
 
     Q_FOREACH(Textarea* area, d->textareas) {
@@ -67,11 +64,11 @@
 
 bool Textlayer::fromXml(QXmlStreamReader *xmlReader)
 {
-    setBgcolor(xmlReader->attributes().value("bgcolor").toString());
-    setLanguage(xmlReader->attributes().value("lang").toString());
+    setBgcolor(xmlReader->attributes().value(QStringLiteral("bgcolor")).toString());
+    setLanguage(xmlReader->attributes().value(QStringLiteral("lang")).toString());
     while(xmlReader->readNextStartElement())
     {
-        if(xmlReader->name() == "text-area")
+        if(xmlReader->name() == QStringLiteral("text-area"))
         {
             Textarea* newArea = new Textarea(this);
             if(!newArea->fromXml(xmlReader)) {
@@ -92,37 +89,37 @@
     return !xmlReader->hasError();
 }
 
-QString Textlayer::language()
+QString Textlayer::language() const
 {
     return d->language;
 }
 
-void Textlayer::setLanguage(QString language)
+void Textlayer::setLanguage(const QString& language)
 {
     d->language = language;
 }
 
-QString Textlayer::bgcolor()
+QString Textlayer::bgcolor() const
 {
     return d->bgcolor;
 }
 
-void Textlayer::setBgcolor(QString newColor)
+void Textlayer::setBgcolor(const QString& newColor)
 {
     d->bgcolor = newColor;
 }
 
-QList<Textarea *> Textlayer::textareas()
+QList<Textarea *> Textlayer::textareas() const
 {
     return d->textareas;
 }
 
-Textarea * Textlayer::textarea(int index)
+Textarea * Textlayer::textarea(int index) const
 {
     return d->textareas.at(index);
 }
 
-int Textlayer::textareaIndex(Textarea* textarea)
+int Textlayer::textareaIndex(Textarea* textarea) const
 {
     return d->textareas.indexOf(textarea);
 }
diff --git a/src/app/CMakeLists.txt b/src/app/CMakeLists.txt
--- a/src/app/CMakeLists.txt
+++ b/src/app/CMakeLists.txt
@@ -15,6 +15,7 @@
     Qt5::OpenGL
     KF5::I18n
     KF5::Declarative
+    peruse_helpers
 )
 
 install(TARGETS peruse ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/src/app/main.cpp b/src/app/main.cpp
--- a/src/app/main.cpp
+++ b/src/app/main.cpp
@@ -17,56 +17,19 @@
  *
  */
 
-#include <QQmlEngine>
-#include <QQmlContext>
-#include <QQmlComponent>
-
 #include <QStandardPaths>
 #include <QDir>
 #include <QDebug>
-#include <QThread>
 
-#include <KDeclarative/KDeclarative>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QCommandLineOption>
 
 #include <iostream>
 
-#include <QOpenGLContext>
-#include <QOffscreenSurface>
-#include <QOpenGLFunctions>
-
-int getMaxTextureSize()
-{
-    int maxSize = 0;
-
-    // Create a temp context - required if this is called from another thread
-    QOpenGLContext ctx;
-    if ( !ctx.create() )
-    {
-        // TODO handle the error
-        qDebug() << "No OpenGL context could be created, this is clearly bad...";
-        exit(-1);
-    }
-
-    // rather than using a QWindow - which actually dosen't seem to work in this case either!
-    QOffscreenSurface surface;
-    surface.setFormat( ctx.format() );
-    surface.create();
-
-    ctx.makeCurrent(&surface);
-
-    // Now the call works
-    QOpenGLFunctions glFuncs(QOpenGLContext::currentContext());
-    glFuncs.glEnable(GL_TEXTURE_2D);
-    glFuncs.glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
-
-    return maxSize;
-}
-
+#include "peruse_helpers.h"
 
 int main(int argc, char** argv)
 {
@@ -91,72 +54,9 @@
             QFile::remove(dbfile);
         }
     }
-
-    KDeclarative::KDeclarative kdeclarative;
-    QQmlEngine engine;
-    kdeclarative.setDeclarativeEngine(&engine);
-    kdeclarative.setupBindings();
-
-    bool osIsWindows = false;
-#ifdef Q_OS_WIN
-    // Because windows is a bit funny with paths and whatnot, just so the thing with the lib paths...
-    QDir appdir(qApp->applicationDirPath());
-    appdir.cdUp();
-    qApp->addLibraryPath(appdir.canonicalPath() + "/lib");
-    engine.addImportPath(appdir.canonicalPath() + "/lib/qml");
-    engine.addImportPath(appdir.canonicalPath() + "/qml");
-    osIsWindows = true;
-    // Hey, let's try and avoid all those extra stale processes, right?
-    qputenv("KDE_FORK_SLAVES", "true");
-#endif
-    engine.rootContext()->setContextProperty("osIsWindows", osIsWindows);
-
-    QQmlContext* objectContext = engine.rootContext();
     QString platformEnv(qgetenv("PLASMA_PLATFORM"));
-    engine.rootContext()->setContextProperty("PLASMA_PLATFORM", platformEnv);
-    // Yes, i realise this is a touch on the ugly side. I have found no better way to allow for
-    // things like the archive book model to create imageproviders for the archives
-    engine.rootContext()->setContextProperty("globalQmlEngine", &engine);
-    engine.rootContext()->setContextProperty("maxTextureSize", getMaxTextureSize());
-
-    QString path;
-    if (platformEnv.startsWith("phone")) {
-        path = QStandardPaths::locate(QStandardPaths::AppDataLocation, "qml/MobileMain.qml");
-    } else {
-        path = QStandardPaths::locate(QStandardPaths::AppDataLocation, "qml/Main.qml");
-    }
-    if(path.isEmpty()) {
-        qCritical() << "The file structure is not set up currectly, and our data is somewhere weird.";
-        path = QString("%1/data/peruse/qml/Main.qml").arg(qApp->applicationDirPath());
-    }
-    int rt = 0;
-    QQmlComponent component(&engine, path);
-    if (component.isError())
-    {
-        qCritical() << "Failed to load the component from disk. Reported error was:" << component.errorString();
-        rt = -1;
-    }
-    else
-    {
-        if(component.status() == QQmlComponent::Ready)
-        {
-            QObject* obj = component.create(objectContext);
-            if(obj)
-            {
-                rt = app.exec();
-            }
-            else
-            {
-                qCritical() << "Failed to create an object from our component";
-                rt = -2;
-            }
-        }
-        else
-        {
-            qCritical() << "Failed to make the Qt Quick component ready. Status is:" << component.status();
-            rt = -3;
-        }
-    }
+    QString path = QStandardPaths::locate(QStandardPaths::AppDataLocation,
+        platformEnv.startsWith("phone") ? "qml/MobileMain.qml" : "qml/Main.qml");
 
-    return rt;
+    return PeruseHelpers::init(path, app);
 }
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/src/common/CMakeLists.txt
@@ -0,0 +1,5 @@
+add_library(peruse_helpers STATIC peruse_helpers.cpp )
+target_link_libraries(peruse_helpers
+    KF5::Declarative
+    Qt5::OpenGL
+)
diff --git a/src/common/peruse_helpers.h b/src/common/peruse_helpers.h
new file mode 100644
--- /dev/null
+++ b/src/common/peruse_helpers.h
@@ -0,0 +1,14 @@
+#ifndef PERUSE_HELPERS_H
+#define PERUSE_HELPERS_H
+
+#include <QString>
+
+class QQmlEngine;
+class QApplication;
+
+namespace PeruseHelpers {
+    int getMaxTextureSize();
+    int init(QString& path, QApplication& app);
+}
+
+#endif
diff --git a/src/creator/main.cpp b/src/common/peruse_helpers.cpp
copy from src/creator/main.cpp
copy to src/common/peruse_helpers.cpp
--- a/src/creator/main.cpp
+++ b/src/common/peruse_helpers.cpp
@@ -1,44 +1,20 @@
-/*
- * Copyright (C) 2016 Dan Leinir Turthra Jensen <admin@leinir.dk>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
+#include "peruse_helpers.h"
 #include <QQmlEngine>
-#include <QQmlContext>
+#include <QString>
 #include <QQmlComponent>
-
+#include <QQmlContext>
 #include <QStandardPaths>
-#include <QDir>
-#include <QDebug>
-#include <QThread>
-
-#include <KDeclarative/KDeclarative>
-#include <KLocalizedString>
-
 #include <QApplication>
-#include <QCommandLineParser>
-#include <QCommandLineOption>
-
-#include <iostream>
-
 #include <QOpenGLContext>
 #include <QOffscreenSurface>
 #include <QOpenGLFunctions>
+#include <QDebug>
+
+#include <KDeclarative/KDeclarative>
+
+#include "peruse_helpers.h"
 
+namespace PeruseHelpers {
 int getMaxTextureSize()
 {
     int maxSize = 0;
@@ -67,21 +43,7 @@
     return maxSize;
 }
 
-
-int main(int argc, char** argv)
-{
-    QApplication app(argc, argv);
-    app.setApplicationDisplayName("Peruse Creator");
-
-    QCommandLineParser parser;
-    // TODO file option for opening comics by passing them through on the command line
-    parser.addHelpOption();
-    parser.process(app);
-
-    if (parser.positionalArguments().size() > 1) {
-        parser.showHelp(1);
-    }
-
+int init(QString &path, QApplication& app) {
     KDeclarative::KDeclarative kdeclarative;
     QQmlEngine engine;
     kdeclarative.setDeclarativeEngine(&engine);
@@ -92,13 +54,14 @@
     // Because windows is a bit funny with paths and whatnot, just so the thing with the lib paths...
     QDir appdir(qApp->applicationDirPath());
     appdir.cdUp();
-    engine.addImportPath(appdir.canonicalPath() + "/lib/qml");
+    qApp->addLibraryPath(appdir.canonicalPath() + "/lib");
     engine.addImportPath(appdir.canonicalPath() + "/lib/qml");
     engine.addImportPath(appdir.canonicalPath() + "/qml");
     osIsWindows = true;
     // Hey, let's try and avoid all those extra stale processes, right?
     qputenv("KDE_FORK_SLAVES", "true");
 #endif
+
     engine.rootContext()->setContextProperty("osIsWindows", osIsWindows);
 
     QQmlContext* objectContext = engine.rootContext();
@@ -109,39 +72,27 @@
     engine.rootContext()->setContextProperty("globalQmlEngine", &engine);
     engine.rootContext()->setContextProperty("maxTextureSize", getMaxTextureSize());
 
-    QString path= QStandardPaths::locate(QStandardPaths::DataLocation, "qml/Main.qml");
     if(path.isEmpty()) {
         qCritical() << "The file structure is not set up currectly, and our data is somewhere weird.";
-        path = QString("%1/data/perusecreator/qml/Main.qml").arg(qApp->applicationDirPath());
+        path = QString("%1/data/peruse/qml/Main.qml").arg(qApp->applicationDirPath());
     }
-    int rt = 0;
+
     QQmlComponent component(&engine, path);
-    if (component.isError())
-    {
+    if (component.isError()) {
         qCritical() << "Failed to load the component from disk. Reported error was:" << component.errorString();
-        rt = -1;
+        return -1;
     }
-    else
-    {
-        if(component.status() == QQmlComponent::Ready)
-        {
-            QObject* obj = component.create(objectContext);
-            if(obj)
-            {
-                rt = app.exec();
-            }
-            else
-            {
-                qCritical() << "Failed to create an object from our component";
-                rt = -2;
-            }
-        }
-        else
-        {
-            qCritical() << "Failed to make the Qt Quick component ready. Status is:" << component.status();
-            rt = -3;
-        }
+    if (component.status() != QQmlComponent::Ready) {
+        qCritical() << "Failed to make the Qt Quick component ready. Status is:" << component.status();
+        return -3;
     }
 
-    return rt;
+    QObject* obj = component.create(objectContext);
+    if (!obj) {
+        qCritical() << "Failed to create an object from our component";
+        return -2;
+    }
+
+    return app.exec();
+}
 }
diff --git a/src/contentlist/ContentList.cpp b/src/contentlist/ContentList.cpp
--- a/src/contentlist/ContentList.cpp
+++ b/src/contentlist/ContentList.cpp
@@ -196,11 +196,11 @@
 
 QHash<int, QByteArray> ContentList::roleNames() const
 {
-    QHash<int, QByteArray> roles;
-    roles[FilenameRole] = "filename";
-    roles[FilePathRole] = "filePath";
-    roles[MetadataRole] = "metadata";
-    return roles;
+    return {
+        { FilenameRole, "filename"},
+        { FilePathRole, "filePath"},
+        { MetadataRole, "metadata"}
+    };
 }
 
 QVariant ContentList::data(const QModelIndex& index, int role) const
diff --git a/src/contentlist/ContentQuery.cpp b/src/contentlist/ContentQuery.cpp
--- a/src/contentlist/ContentQuery.cpp
+++ b/src/contentlist/ContentQuery.cpp
@@ -102,74 +102,93 @@
     emit mimeTypesChanged();
 }
 
-QStringList ContentQuery::Private::mimeTypesForType(ContentQuery::Type type)
-{
-    QStringList result;
-    QMimeDatabase mimeDatabase;
+namespace {
+    QStringList contentQueryVideo () {
+        return {
+            QStringLiteral("video/x-matroska"),
+            QStringLiteral("video/mp4"),
+            QStringLiteral("video/mpeg"),
+            QStringLiteral("video/ogg"),
+            QStringLiteral("video/quicktime"),
+            QStringLiteral("video/webm"),
+            QStringLiteral("video/x-ms-wmv"),
+            QStringLiteral("video/x-msvideo"),
+            QStringLiteral("video/x-ogm+ogg"),
+            QStringLiteral("video/x-theora+ogg"),
+        };
+    }
 
-    //TODO: Find a better solution for this.
-    switch(type) {
-        case ContentQuery::Video:
-            result << QStringLiteral("video/x-matroska");
-            result << QStringLiteral("video/mp4");
-            result << QStringLiteral("video/mpeg");
-            result << QStringLiteral("video/ogg");
-            result << QStringLiteral("video/quicktime");
-            result << QStringLiteral("video/webm");
-            result << QStringLiteral("video/x-ms-wmv");
-            result << QStringLiteral("video/x-msvideo");
-            result << QStringLiteral("video/x-ogm+ogg");
-            result << QStringLiteral("video/x-theora+ogg");
-            break;
-        case ContentQuery::Audio:
-            result << QStringLiteral("audio/aac");
-            result << QStringLiteral("audio/flac");
-            result << QStringLiteral("audio/mp2");
-            result << QStringLiteral("audio/mp4");
-            result << QStringLiteral("audio/mpeg");
-            result << QStringLiteral("audio/ogg");
-            result << QStringLiteral("audio/webm");
-            result << QStringLiteral("audio/x-opus+ogg");
-            result << QStringLiteral("audio/x-ms-wma");
-            result << QStringLiteral("audio/x-vorbis+ogg");
-            result << QStringLiteral("audio/x-wav");
-            break;
-        case ContentQuery::Documents:
-            result << QStringLiteral("application/vnd.oasis.opendocument.text");
-            result << QStringLiteral("application/vnd.oasis.opendocument.spreadsheet");
-            result << QStringLiteral("application/vnd.oasis.opendocument.presentation");
-            result << QStringLiteral("application/vnd.ms-word");
-            result << QStringLiteral("application/vnd.ms-excel");
-            result << QStringLiteral("application/vnd.ms-powerpoint");
-            result << QStringLiteral("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.xml");
-            result << QStringLiteral("application/vnd.openxmlformats-officedocument.wordprocessingml.document.xml");
-            result << QStringLiteral("application/vnd.openxmlformats-officedocument.presentationml.presentation.xml");
-            result << QStringLiteral("text/plain");
-            result << QStringLiteral("application/pdf");
-            break;
-        case ContentQuery::Images:
+    QStringList contentQueryAudio() {
+        return {
+            QStringLiteral("audio/aac"),
+            QStringLiteral("audio/flac"),
+            QStringLiteral("audio/mp2"),
+            QStringLiteral("audio/mp4"),
+            QStringLiteral("audio/mpeg"),
+            QStringLiteral("audio/ogg"),
+            QStringLiteral("audio/webm"),
+            QStringLiteral("audio/x-opus+ogg"),
+            QStringLiteral("audio/x-ms-wma"),
+            QStringLiteral("audio/x-vorbis+ogg"),
+            QStringLiteral("audio/x-wav")
+        };
+    }
+
+    QStringList contentQueryDocuments () {
+        return {
+            QStringLiteral("application/vnd.oasis.opendocument.text"),
+            QStringLiteral("application/vnd.oasis.opendocument.spreadsheet"),
+            QStringLiteral("application/vnd.oasis.opendocument.presentation"),
+            QStringLiteral("application/vnd.ms-word"),
+            QStringLiteral("application/vnd.ms-excel"),
+            QStringLiteral("application/vnd.ms-powerpoint"),
+            QStringLiteral("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.xml"),
+            QStringLiteral("application/vnd.openxmlformats-officedocument.wordprocessingml.document.xml"),
+            QStringLiteral("application/vnd.openxmlformats-officedocument.presentationml.presentation.xml"),
+            QStringLiteral("text/plain"),
+            QStringLiteral("application/pdf")
+        };
+    }
+
+    QStringList contentQueryImages() {
+        // only popylate once.
+        static QStringList result;
+        if (result.isEmpty()) {
             for(const auto& item : QImageReader::supportedMimeTypes())
             {
                 result << QString::fromUtf8(item);
             }
-            break;
-        case ContentQuery::Comics:
-            result << QStringLiteral("application/x-cbz");
-            result << QStringLiteral("application/x-cbr");
-            result << QStringLiteral("application/x-cb7");
-            result << QStringLiteral("application/x-cbt");
-            result << QStringLiteral("application/x-cba");
-            result << QStringLiteral("application/vnd.comicbook+zip");
-            result << QStringLiteral("application/vnd.comicbook+rar");
-            result << QStringLiteral("application/vnd.ms-htmlhelp");
-            result << QStringLiteral("image/vnd.djvu");
-            result << QStringLiteral("image/x-djvu");
-            result << QStringLiteral("application/epub+zip");
-            result << QStringLiteral("application/pdf");
-            break;
-        default:
-            break;
+        }
+        return result;
     }
 
-    return result;
+    QStringList contentQueryComics() {
+        return {
+            QStringLiteral("application/x-cbz"),
+            QStringLiteral("application/x-cbr"),
+            QStringLiteral("application/x-cb7"),
+            QStringLiteral("application/x-cbt"),
+            QStringLiteral("application/x-cba"),
+            QStringLiteral("application/vnd.comicbook+zip"),
+            QStringLiteral("application/vnd.comicbook+rar"),
+            QStringLiteral("application/vnd.ms-htmlhelp"),
+            QStringLiteral("image/vnd.djvu"),
+            QStringLiteral("image/x-djvu"),
+            QStringLiteral("application/epub+zip"),
+            QStringLiteral("application/pdf")
+        };
+    }
+}
+QStringList ContentQuery::Private::mimeTypesForType(ContentQuery::Type type)
+{
+    QStringList ret{};
+    switch(type) {
+        case ContentQuery::Type::Video:     ret = contentQueryVideo(); break;
+        case ContentQuery::Type::Audio:     ret = contentQueryAudio(); break;
+        case ContentQuery::Type::Documents: ret = contentQueryDocuments(); break;
+        case ContentQuery::Type::Images:    ret = contentQueryImages(); break;
+        case ContentQuery::Type::Comics:    ret = contentQueryComics(); break;
+        case ContentQuery::Type::Any:       /* do nothing */ break;
+    }
+    return ret;
 }
diff --git a/src/creator/CMakeLists.txt b/src/creator/CMakeLists.txt
--- a/src/creator/CMakeLists.txt
+++ b/src/creator/CMakeLists.txt
@@ -15,6 +15,7 @@
     Qt5::OpenGL
     KF5::I18n
     KF5::Declarative
+    peruse_helpers
 )
 
 install(TARGETS perusecreator ${INSTALL_TARGETS_DEFAULT_ARGS})
diff --git a/src/creator/main.cpp b/src/creator/main.cpp
--- a/src/creator/main.cpp
+++ b/src/creator/main.cpp
@@ -17,56 +17,16 @@
  *
  */
 
-#include <QQmlEngine>
-#include <QQmlContext>
-#include <QQmlComponent>
-
 #include <QStandardPaths>
-#include <QDir>
-#include <QDebug>
-#include <QThread>
 
-#include <KDeclarative/KDeclarative>
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QCommandLineOption>
 
 #include <iostream>
-
-#include <QOpenGLContext>
-#include <QOffscreenSurface>
-#include <QOpenGLFunctions>
-
-int getMaxTextureSize()
-{
-    int maxSize = 0;
-
-    // Create a temp context - required if this is called from another thread
-    QOpenGLContext ctx;
-    if ( !ctx.create() )
-    {
-        // TODO handle the error
-        qDebug() << "No OpenGL context could be created, this is clearly bad...";
-        exit(-1);
-    }
-
-    // rather than using a QWindow - which actually dosen't seem to work in this case either!
-    QOffscreenSurface surface;
-    surface.setFormat( ctx.format() );
-    surface.create();
-
-    ctx.makeCurrent(&surface);
-
-    // Now the call works
-    QOpenGLFunctions glFuncs(QOpenGLContext::currentContext());
-    glFuncs.glEnable(GL_TEXTURE_2D);
-    glFuncs.glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
-
-    return maxSize;
-}
-
+#include "peruse_helpers.h"
 
 int main(int argc, char** argv)
 {
@@ -82,66 +42,6 @@
         parser.showHelp(1);
     }
 
-    KDeclarative::KDeclarative kdeclarative;
-    QQmlEngine engine;
-    kdeclarative.setDeclarativeEngine(&engine);
-    kdeclarative.setupBindings();
-
-    bool osIsWindows = false;
-#ifdef Q_OS_WIN
-    // Because windows is a bit funny with paths and whatnot, just so the thing with the lib paths...
-    QDir appdir(qApp->applicationDirPath());
-    appdir.cdUp();
-    engine.addImportPath(appdir.canonicalPath() + "/lib/qml");
-    engine.addImportPath(appdir.canonicalPath() + "/lib/qml");
-    engine.addImportPath(appdir.canonicalPath() + "/qml");
-    osIsWindows = true;
-    // Hey, let's try and avoid all those extra stale processes, right?
-    qputenv("KDE_FORK_SLAVES", "true");
-#endif
-    engine.rootContext()->setContextProperty("osIsWindows", osIsWindows);
-
-    QQmlContext* objectContext = engine.rootContext();
-    QString platformEnv(qgetenv("PLASMA_PLATFORM"));
-    engine.rootContext()->setContextProperty("PLASMA_PLATFORM", platformEnv);
-    // Yes, i realise this is a touch on the ugly side. I have found no better way to allow for
-    // things like the archive book model to create imageproviders for the archives
-    engine.rootContext()->setContextProperty("globalQmlEngine", &engine);
-    engine.rootContext()->setContextProperty("maxTextureSize", getMaxTextureSize());
-
     QString path= QStandardPaths::locate(QStandardPaths::DataLocation, "qml/Main.qml");
-    if(path.isEmpty()) {
-        qCritical() << "The file structure is not set up currectly, and our data is somewhere weird.";
-        path = QString("%1/data/perusecreator/qml/Main.qml").arg(qApp->applicationDirPath());
-    }
-    int rt = 0;
-    QQmlComponent component(&engine, path);
-    if (component.isError())
-    {
-        qCritical() << "Failed to load the component from disk. Reported error was:" << component.errorString();
-        rt = -1;
-    }
-    else
-    {
-        if(component.status() == QQmlComponent::Ready)
-        {
-            QObject* obj = component.create(objectContext);
-            if(obj)
-            {
-                rt = app.exec();
-            }
-            else
-            {
-                qCritical() << "Failed to create an object from our component";
-                rt = -2;
-            }
-        }
-        else
-        {
-            qCritical() << "Failed to make the Qt Quick component ready. Status is:" << component.status();
-            rt = -3;
-        }
-    }
-
-    return rt;
+    return PeruseHelpers::init(path, app);
 }