diff --git a/src/acbf/AcbfPage.cpp b/src/acbf/AcbfPage.cpp
index 5327350..13f9f17 100644
--- a/src/acbf/AcbfPage.cpp
+++ b/src/acbf/AcbfPage.cpp
@@ -1,440 +1,456 @@
 /*
  * Copyright (C) 2015 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "AcbfPage.h"
 #include "AcbfTextlayer.h"
 #include "AcbfFrame.h"
 #include "AcbfJump.h"
 #include "AcbfTextarea.h"
 
 #include <QDebug>
 #include <QHash>
 #include <QXmlStreamReader>
 
 using namespace AdvancedComicBookFormat;
 
 class Page::Private
 {
 public:
     Private()
         : isCoverPage(false)
     {}
     QString bgcolor;
     QString transition;
     QHash<QString, QString> title;
     QString imageHref;
     QHash<QString, Textlayer*> textLayers;
     QList<Frame*> frames;
     QList<Jump*> jumps;
     bool isCoverPage;
 };
 
 Page::Page(Document* parent)
     : QObject(parent)
     , d(new Private)
 {
     qRegisterMetaType<Page*>("Page*");
 }
 
 Page::~Page() = default;
 
 void Page::toXml(QXmlStreamWriter* writer)
 {
     if(d->isCoverPage) {
         writer->writeStartElement(QStringLiteral("coverpage"));
     }
     else {
         writer->writeStartElement(QStringLiteral("page"));
     }
 
     if(!d->bgcolor.isEmpty()) {
         writer->writeAttribute(QStringLiteral("bgcolor"), d->bgcolor);
     }
     if(!d->transition.isEmpty()) {
         writer->writeAttribute(QStringLiteral("transition"), d->transition);
     }
 
     QHashIterator<QString, QString> titles(d->title);
     while(titles.hasNext()) {
         titles.next();
         writer->writeStartElement(QStringLiteral("title"));
         writer->writeAttribute(QStringLiteral("lang"), titles.key());
         writer->writeCharacters(titles.value());
         writer->writeEndElement();
     }
 
     writer->writeStartElement(QStringLiteral("image"));
     writer->writeAttribute(QStringLiteral("href"), d->imageHref);
     writer->writeEndElement();
 
     Q_FOREACH(Textlayer* layer, d->textLayers.values()) {
         layer->toXml(writer);
     }
 
      Q_FOREACH(Frame* frame, d->frames) {
          frame->toXml(writer);
      }
 
      Q_FOREACH(Jump* jump, d->jumps) {
          jump->toXml(writer);
      }
 
     writer->writeEndElement();
 }
 
 bool Page::fromXml(QXmlStreamReader *xmlReader)
 {
     setBgcolor(xmlReader->attributes().value(QStringLiteral("bgcolor")).toString());
     setTransition(xmlReader->attributes().value(QStringLiteral("transition")).toString());
     while(xmlReader->readNextStartElement())
     {
         if(xmlReader->name() == QStringLiteral("title"))
         {
             d->title[xmlReader->attributes().value(QStringLiteral("lang")).toString()] = xmlReader->readElementText();
         }
         else if(xmlReader->name() == QStringLiteral("image"))
         {
             /**
              * There are some acbf files out there that have backslashes in their
              * image href. This is probably a mistake from windows users, but not proper XML.
              * We should thus replace those with forward slashes so the image can be loaded.
              */
             QString href = xmlReader->attributes().value(QStringLiteral("href")).toString();
             setImageHref(href.replace(QStringLiteral("\\"), QStringLiteral("/"))); 
             xmlReader->skipCurrentElement();
         }
         else if(xmlReader->name() == QStringLiteral("text-layer"))
         {
             Textlayer* newLayer = new Textlayer(this);
             if(!newLayer->fromXml(xmlReader)) {
                 return false;
             }
             d->textLayers[newLayer->language()] = newLayer;
         }
         else if(xmlReader->name() == QStringLiteral("frame"))
         {
             Frame* newFrame = new Frame(this);
             if(!newFrame->fromXml(xmlReader)) {
                 return false;
             }
             d->frames.append(newFrame);
 
             // Frames have no child elements, so we need to force the reader to go to the next one.
             xmlReader->readNext();
         }
          else if(xmlReader->name() == QStringLiteral("jump"))
          {
              Jump* newJump = new Jump(this);
              if(!newJump->fromXml(xmlReader)) {
                  return false;
              }
              
              // Jumps have no child elements, so we need to force the reader to go to the next one.
              d->jumps.append(newJump);
              xmlReader->readNext();
          }
         else
         {
             qWarning() << Q_FUNC_INFO << "currently unsupported subsection:" << xmlReader->name();
             xmlReader->skipCurrentElement();
         }
     }
     if (xmlReader->hasError()) {
         qWarning() << Q_FUNC_INFO << "Failed to read ACBF XML document at token" << xmlReader->name() << "(" << xmlReader->lineNumber() << ":" << xmlReader->columnNumber() << ") The reported error was:" << xmlReader->errorString();
     }
     qDebug() << Q_FUNC_INFO << "Created page for image" << d->imageHref;
     return !xmlReader->hasError();
 }
 
 QString Page::bgcolor() const
 {
     return d->bgcolor;
 }
 
 void Page::setBgcolor(const QString& newColor)
 {
     d->bgcolor = newColor;
     emit bgcolorChanged();
 }
 
 QString Page::transition() const
 {
     return d->transition;
 }
 
 void Page::setTransition(const QString& transition)
 {
     d->transition = transition;
     emit transitionChanged();
 }
 
 QStringList Page::availableTransitions()
 {
     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() const
 {
     return d->title.values();
 }
 
 QString Page::title(const QString& language) const
 {
     if (d->title.count()==0) {
         return "";
     }
     if (!d->title.keys().contains(language)) {
         d->title.values().at(0);
     }
 
     QString title = d->title.value(language);
 
     if (title.isEmpty()) {
         title = d->title.values().at(0);
     }
 
     return title;
 }
 
 void Page::setTitle(const QString& title, const QString& language)
 {
     if(title.isEmpty())
     {
         d->title.remove(language);
     }
     else
     {
         d->title[language] = title;
     }
     emit titlesChanged();
 }
 
 QString Page::imageHref() const
 {
     return d->imageHref;
 }
 
 void Page::setImageHref(const QString& imageHref)
 {
     d->imageHref = imageHref;
 }
 
 QList<Textlayer *> Page::textLayersForAllLanguages() const
 {
     return d->textLayers.values();
 }
 
 Textlayer * Page::textLayer(const QString& language) const
 {
     if (!d->textLayers.keys().contains("") && language == QString()) {
         return d->textLayers.values().at(0);
     }
     return d->textLayers.value(language);
 }
 
 void Page::setTextLayer(Textlayer* textlayer, const QString& language)
 {
     if(textlayer)
     {
         d->textLayers[language] = textlayer;
     }
     else
     {
         d->textLayers.remove(language);
     }
     emit textLayerLanguagesChanged();
 }
 
 void Page::addTextLayer(const QString &language)
 {
     Textlayer* textLayer = new Textlayer(this);
     textLayer->setLanguage(language);
     setTextLayer(textLayer, language);
 }
 
 void Page::removeTextLayer(const QString &language)
 {
     setTextLayer(nullptr, language);
 }
 
 void Page::duplicateTextLayer(const QString &languageFrom, const QString &languageTo)
 {
     Textlayer* to = new Textlayer(this);
     to->setLanguage(languageTo);
     if (d->textLayers[languageFrom]) {
         Textlayer* from = d->textLayers[languageFrom];
         to->setBgcolor(from->bgcolor());
-        for (int i=0; i<from->textareaCount(); i++) {
+        for (int i=0; i<from->textareaPointStrings().size(); i++) {
             to->addTextarea(i);
             to->textarea(i)->setBgcolor(from->textarea(i)->bgcolor());
             to->textarea(i)->setInverted(from->textarea(i)->inverted());
             to->textarea(i)->setTransparent(from->textarea(i)->transparent());
             to->textarea(i)->setTextRotation(from->textarea(i)->textRotation());
             to->textarea(i)->setType(from->textarea(i)->type());
             to->textarea(i)->setParagraphs(from->textarea(i)->paragraphs());
             for (int p=0; p<from->textarea(i)->pointCount(); p++) {
                 to->textarea(i)->addPoint(from->textarea(i)->point(p));
             }
         }
     }
     setTextLayer(to);
 }
 
 QStringList Page::textLayerLanguages() const
 {
     if (d->textLayers.isEmpty()) {
         return QStringList();
     }
     return d->textLayers.keys();
 }
 
 QList<Frame *> Page::frames() const
 {
     return d->frames;
 }
 
 Frame * Page::frame(int index) const
 {
     return d->frames.at(index);
 }
 
 int Page::frameIndex(Frame* frame) const
 {
     return d->frames.indexOf(frame);
 }
 
 void Page::addFrame(Frame* frame, int index)
 {
     if(index > -1 && d->frames.count() < index) {
         d->frames.insert(index, frame);
     }
     else {
         d->frames.append(frame);
     }
-    emit frameCountChanged();
+    emit framePointStringsChanged();
 }
 
 void Page::removeFrame(Frame* frame)
 {
     d->frames.removeAll(frame);
-    emit frameCountChanged();
+    emit framePointStringsChanged();
 }
 
 void Page::removeFrame(int index)
 {
     removeFrame(frame(index));
 }
 
 void Page::addFrame(int index)
 {
     Frame* frame = new Frame(this);
     addFrame(frame, index);
 }
 
 bool Page::swapFrames(int swapThis, int withThis)
 {
     if(swapThis > -1 && withThis > -1) {
         d->frames.swap(swapThis, withThis);
-        emit frameCountChanged();
+        emit framePointStringsChanged();
         return true;
     }
     return false;
 }
 
-int Page::frameCount()
+QStringList Page::framePointStrings()
 {
-    return d->frames.size();
+    QStringList frameList;
+    for (int i=0; i<d->frames.size(); i++) {
+        QStringList framePoints;
+        for (int p=0; p< frame(i)->pointCount(); p++) {
+            framePoints.append(QString("%1,%2").arg(frame(i)->point(p).x()).arg(frame(i)->point(p).y()));
+        }
+        frameList.append(framePoints.join(" "));
+    }
+    return frameList;
 }
 
 QList<Jump *> Page::jumps() const
 {
     return d->jumps;
 }
 
 Jump * Page::jump(int index) const
 {
     return d->jumps.at(index);
 }
 
 int Page::jumpIndex(Jump* jump) const
 {
     return d->jumps.indexOf(jump);
 }
 
 void Page::addJump(Jump* jump, int index)
 {
     if(index > -1 && d->jumps.count() < index) {
         d->jumps.insert(index, jump);
     }
     else {
         d->jumps.append(jump);
     }
-    emit jumpCountChanged();
+    emit jumpPointStringsChanged();
 }
 
 void Page::addJump(int pageIndex, int index)
 {
     Jump* jump = new Jump(this);
     jump->setPageIndex(pageIndex);
     addJump(jump, index);
 }
 
 void Page::removeJump(Jump* jump)
 {
     d->jumps.removeAll(jump);
-    emit jumpCountChanged();
+    emit jumpPointStringsChanged();
 }
 
 void Page::removeJump(int index)
 {
     removeJump(jump(index));
 }
 
 bool Page::swapJumps(int swapThis, int withThis)
 {
     if(swapThis > -1 && withThis > -1) {
         d->jumps.swap(swapThis, withThis);
-        emit jumpCountChanged();
+        emit jumpPointStringsChanged();
         return true;
     }
     return false;
 }
 
-int Page::jumpCount()
+QStringList Page::jumpPointStrings()
 {
-    return d->jumps.size();
+    QStringList jumpList;
+    for (int i=0; i<d->jumps.size(); i++) {
+        QStringList points;
+        for (int p=0; p< jump(i)->pointCount(); p++) {
+            points.append(QString("%1,%2").arg(jump(i)->point(p).x()).arg(jump(i)->point(p).y()));
+        }
+        jumpList.append(points.join(" "));
+    }
+    return jumpList;
 }
 
 bool Page::isCoverPage() const
 {
     return d->isCoverPage;
 }
 
 void Page::setIsCoverPage(bool isCoverPage)
 {
     d->isCoverPage = isCoverPage;
 }
diff --git a/src/acbf/AcbfPage.h b/src/acbf/AcbfPage.h
index d9fcc0c..71ac3b3 100644
--- a/src/acbf/AcbfPage.h
+++ b/src/acbf/AcbfPage.h
@@ -1,324 +1,327 @@
 /*
  * Copyright (C) 2015 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef ACBFPAGE_H
 #define ACBFPAGE_H
 
 #include "AcbfDocument.h"
 /**
  * \brief Class to handle page objects.
  * 
  * A proper ACBF document should have entries for all pages
  * and said entries should point at the images that make up
  * the comic.
  * 
  * However, ACBF also has room from frame definitions, transcriptions,
  * translations, table of contents, jumps and more.
  * 
  * The frame definitions are used to navigate a page and zoom efficiently on a
  * small screen. Similarly, transscriptions and translations can be used to show
  * text when the image itself is too blurry.
  * 
  * Title is used to generate a table of contents.
  * 
  * Transition is to indicate extra information about how the page should be entered.
  * 
  * bgcolor is used by the reading software to determine what background color to give.
  * 
  * Jumps can be used to move around in the comic.
  * 
  * TODO: Frame and Jump seem to be missing classes despite being used here?
  */
 class QXmlStreamWriter;
 class QXmlStreamReader;
 namespace AdvancedComicBookFormat
 {
 class Textlayer;
 class Frame;
 class Jump;
 class ACBF_EXPORT Page : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString bgcolor READ bgcolor WRITE setBgcolor NOTIFY bgcolorChanged)
     Q_PROPERTY(QString transition READ transition WRITE setTransition NOTIFY transitionChanged)
     Q_PROPERTY(QString imageHref READ imageHref WRITE setImageHref NOTIFY imageHrefChanged)
     Q_PROPERTY(QStringList textLayerLanguages READ textLayerLanguages NOTIFY textLayerLanguagesChanged)
-    Q_PROPERTY(int frameCount READ frameCount NOTIFY frameCountChanged)
-    Q_PROPERTY(int jumpCount READ jumpCount NOTIFY jumpCountChanged)
+    Q_PROPERTY(QStringList framePointStrings READ framePointStrings NOTIFY framePointStringsChanged)
+    Q_PROPERTY(QStringList jumpPointStrings READ jumpPointStrings NOTIFY jumpPointStringsChanged)
 public:
     // Pages can also be cover pages, which means they can also be children of BookInfo
     explicit Page(Document* parent = nullptr);
     ~Page() override;
 
     /**
      * \brief Write the page into the xml writer.
      */
     void toXml(QXmlStreamWriter* writer);
     /**
      * \brief load a page element into this object.
      * @return True if the xmlReader encountered no errors.
      */
     bool fromXml(QXmlStreamReader *xmlReader);
 
     /**
      * @return the background color as a QString.
      * 
      * It should be an 8bit per channel rgb hexcode.
      */
     QString bgcolor() const;
     /**
      * \brief set the background color.
      * 
      * @param newColor - a String with an 8bit per channel rgb hexcode (#ff00ff, or the like)
      */
     void setBgcolor(const QString& newColor = QString());
     /**
      * @brief fires when the background color changes.
      */
     Q_SIGNAL void bgcolorChanged();
     /**
      * @return transition type as a string.
      */
     QString transition() const;
     /**
      * \brief set the transition type.
      * @param transition - the transition type, possible entries are in the availableTransitions() stringlist.
      */
     void setTransition(const QString& transition);
     /**
      * @brief fires when the transition type changes.
      */
     Q_SIGNAL void transitionChanged();
     /**
      * @returns a list of strings that can be used for the transition.
      */
     Q_INVOKABLE static QStringList availableTransitions();
 
     /**
      * @return all titles for this page in all languages.
      */
     Q_INVOKABLE QStringList titleForAllLanguages() const;
     /**
      * @param language - the language of the entry in language code, country
      * code format joined by a dash (not an underscore).
      * @return the title for this language.
      */
     Q_INVOKABLE QString title(const QString& language = QString()) const;
     /**
      * \brief set the title for this language.
      * @param language - the language of the entry in language code, country
      * code format joined by a dash (not an underscore).
      */
     Q_INVOKABLE void setTitle(const QString& title, const QString& language = QString());
     /**
      * @brief titlesChanged
      */
     Q_SIGNAL void titlesChanged();
 
     /**
      * @returns the URI for the image of this page as a QString
      */
     QString imageHref() const;
     /**
      * \brief set the URI for the image of this page.
      * @param imageHref - the URI to an image.
      * 
      *  - A Binary representation will use the ID of that representation.
      *  - A reference to a file on the internet will start with "http://" or "https://"
      *  - A reference to a file in a zip will be prefixed with "zip:"
      *  - Everything else is presumed to be a file on disk.
      */
     void setImageHref(const QString& imageHref);
     /**
      * @brief fires when the image url changes.
      */
     Q_SIGNAL void imageHrefChanged();
 
     /**
      * @returns all the textlayers objects.
      */
     QList<Textlayer*> textLayersForAllLanguages() const;
     /**
      * @param language - the language of the entry in language code, country
      * code format joined by a dash (not an underscore).
      * @returns the TextLayer object for that language.
      */
     Q_INVOKABLE Textlayer* textLayer(const QString& language = QString()) const;
     /**
      * 
      * @param language - the language of the entry in language code, country
      * code format joined by a dash (not an underscore). 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, const QString& language = QString());
     /**
      * @brief add a textlayer for language.
      * @param language code to add a textlayer for.
      */
     Q_INVOKABLE void addTextLayer(const QString& language = QString());
     /**
      * @brief remove a text layer by language.
      * @param language code to remove the textlayer for.
      */
     Q_INVOKABLE void removeTextLayer(const QString& language = QString());
     /**
      * @brief duplicate a text layer to a different language, if languageFrom doesn't
      * exist this makes a new text layer.
      * @param languageFrom the language from which to duplicate.
      * @param languageTo the language to make the new text layer at.
      */
     Q_INVOKABLE void duplicateTextLayer(const QString&languageFrom, const QString& languageTo = QString());
     /**
      * @brief get the possible translations.
      * @return a stringlist with all the languages available.
      */
     QStringList textLayerLanguages() const;
     /**
      * @brief fires when the textlayer languages list changes
      *
      * this can happen when text layers are added or removed.
      */
     Q_SIGNAL void textLayerLanguagesChanged();
 
     /**
      * @returns a list of frames in this page.
      */
     QList<Frame*> frames() const;
     /**
      * @param index - index of the frame.
      * @return the frame of that index.
      */
     Q_INVOKABLE Frame* frame(int index) const;
     /**
      * @param frame - the frame you want to index of.
      * @returns the index of the given frame.
      */
     int frameIndex(Frame* frame) const;
 
     /**
      * \brief add a frame to the list of frames.
      * @param frame - the frame to add.
      * @param index - the index to add it at. If afterIndex is larger than
      * zero, the insertion will happen at that index
      */
     void addFrame(Frame* frame, int index = -1);
     /**
      * \brief remove the given frame from the framelist.
      * @param frame - the frame to remove.
      */
     void removeFrame(Frame* frame);
     /**
      * @brief remove frame by index.
      * @param index index of the frame to remove.
      */
     Q_INVOKABLE void removeFrame(int index);
     /**
      * @brief add a frame at index..
      * @param index - the index to add it at. If afterIndex is larger than
      * zero, the insertion will happen at that index
      */
     Q_INVOKABLE void addFrame(int index = -1);
     /**
      * \brief Swap two frames in the list.
      * @param swapThis - the first index to swap.
      * @param withThis - the second index to swap.
      */
     Q_INVOKABLE bool swapFrames(int swapThis, int withThis);
     /**
-     * @brief frameCount
-     * @return the total amount of frames.
+     * @brief returns the amount of frames as a stringlist.
+     * This is a hack to ensure that qml repeaters may update properly.
+     * @return a string list containing strings with the point counts of said frames.
      */
-    int frameCount();
+    QStringList framePointStrings();
     /**
-     * @brief fires when the frame count changes.
+     * @brief fires when the frame point strings change.
      */
-    Q_SIGNAL void frameCountChanged();
+    Q_SIGNAL void framePointStringsChanged();
 
     /**
      * @return the list of jump objects for this page.
      */
     QList<Jump*> jumps() const;
     /**
      * @param index - the index for which you want the jump object.
      * @return a jump object for the given frame.
      */
     Q_INVOKABLE Jump* jump(int index) const;
     /**
      * @param jump - the jump you want to index of.
      * @returns the index of the given jump.
      */
     int jumpIndex(Jump* jump) const;
 
     /**
      * \brief add a jump to the list of frames.
      * @param jump - the jump to add.
      * @param index - the index to add it at. If afterIndex is larger than
      * zero, the insertion will happen at that index
      */
     void addJump(Jump* jump, int index = -1);
     /**
      * @brief addJump
      * @param index - the index to add it at. If afterIndex is larger than
      * zero, the insertion will happen at that index
      */
     Q_INVOKABLE void addJump(int pageIndex, int index = -1);
     /**
      * \brief remove the given jump from the list of jumps.
      * @param jump - the jump to remove.
      */
     void removeJump(Jump* jump);
     /**
      * @brief removeJump
      * @param index to remove the jump at.
      */
     Q_INVOKABLE void removeJump(int index);
     /**
      * \brief Swap two jumps in the list.
      * @param swapThis - the first index to swap.
      * @param withThis - the second index to swap.
      */
     Q_INVOKABLE bool swapJumps(int swapThis, int withThis);
     /**
      * @brief the amount of jumps on this page.
+     * This is a hack to ensure QML updates properly when swapJumps is called.
+     * @returns a QStringlist with the jump's points.
      */
-    int jumpCount();
+    QStringList jumpPointStrings();
     /**
-     * @brief changes when the jumpcount changes.
+     * @brief changes when the jump point strings change.
      */
-    Q_SIGNAL void jumpCountChanged();
+    Q_SIGNAL void jumpPointStringsChanged();
 
     /**
      * @returns whether this is the cover page.
      */
     bool isCoverPage() const;
     /**
      * \brief toggle whether this is the cover page.
      * 
      */
     void setIsCoverPage(bool isCoverPage = false);
 private:
     class Private;
     std::unique_ptr<Private> d;
 };
 }
 
 #endif//ACBFPAGE_H
diff --git a/src/acbf/AcbfTextlayer.cpp b/src/acbf/AcbfTextlayer.cpp
index dbb87e6..74c54f4 100644
--- a/src/acbf/AcbfTextlayer.cpp
+++ b/src/acbf/AcbfTextlayer.cpp
@@ -1,171 +1,179 @@
 /*
  * 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "AcbfTextlayer.h"
 #include "AcbfTextarea.h"
 
 #include <QDebug>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
 using namespace AdvancedComicBookFormat;
 
 class Textlayer::Private
 {
 public:
     Private() {}
     QString language;
     QString bgcolor;
     QList<Textarea*> textareas;
 };
 
 Textlayer::Textlayer(Page* parent)
     : QObject(parent)
     , d(new Private)
 {
     qRegisterMetaType<Textlayer*>("Textlayer*");
 }
 
 Textlayer::~Textlayer() = default;
 
 void Textlayer::toXml(QXmlStreamWriter* writer)
 {
     writer->writeStartElement(QStringLiteral("text-layer"));
     if(!d->language.isEmpty()) {
         writer->writeAttribute(QStringLiteral("lang"), d->language);
     }
     if(!d->bgcolor.isEmpty()) {
         writer->writeAttribute(QStringLiteral("bgcolor"), d->bgcolor);
     }
 
     Q_FOREACH(Textarea* area, d->textareas) {
         area->toXml(writer);
     }
 
     writer->writeEndElement();
 }
 
 bool Textlayer::fromXml(QXmlStreamReader *xmlReader)
 {
     setBgcolor(xmlReader->attributes().value(QStringLiteral("bgcolor")).toString());
     setLanguage(xmlReader->attributes().value(QStringLiteral("lang")).toString());
     while(xmlReader->readNextStartElement())
     {
         if(xmlReader->name() == QStringLiteral("text-area"))
         {
             Textarea* newArea = new Textarea(this);
             if(!newArea->fromXml(xmlReader)) {
                 return false;
             }
             d->textareas.append(newArea);
         }
         else
         {
             qWarning() << Q_FUNC_INFO << "currently unsupported subsection:" << xmlReader->name();
             xmlReader->skipCurrentElement();
         }
     }
     if (xmlReader->hasError()) {
         qWarning() << Q_FUNC_INFO << "Failed to read ACBF XML document at token" << xmlReader->name() << "(" << xmlReader->lineNumber() << ":" << xmlReader->columnNumber() << ") The reported error was:" << xmlReader->errorString();
     }
     qDebug() << Q_FUNC_INFO << "Created a text layer with" << d->textareas.count() << "text areas";
     return !xmlReader->hasError();
 }
 
 QString Textlayer::language() const
 {
     return d->language;
 }
 
 void Textlayer::setLanguage(const QString& language)
 {
     d->language = language;
     emit languageChanged();
 }
 
 QString Textlayer::bgcolor() const
 {
     return d->bgcolor;
 }
 
 void Textlayer::setBgcolor(const QString& newColor)
 {
     d->bgcolor = newColor;
     emit bgcolorChanged();
 }
 
 QList<Textarea *> Textlayer::textareas() const
 {
     return d->textareas;
 }
 
 Textarea * Textlayer::textarea(int index) const
 {
     return d->textareas.at(index);
 }
 
 int Textlayer::textareaIndex(Textarea* textarea) const
 {
     return d->textareas.indexOf(textarea);
 }
 
 void Textlayer::addTextarea(Textarea* textarea, int index)
 {
     if(index > -1 && d->textareas.count() < index) {
         d->textareas.insert(index, textarea);
     }
     else {
         d->textareas.append(textarea);
     }
-    emit textareaCountChanged();
+    emit textareaPointStringsChanged();
 }
 
 void Textlayer::addTextarea(int index)
 {
     Textarea* text = new Textarea(this);
     addTextarea(text, index);
 }
 
 void Textlayer::removeTextarea(Textarea* textarea)
 {
     d->textareas.removeAll(textarea);
-    emit textareaCountChanged();
+    emit textareaPointStringsChanged();
 }
 
 void Textlayer::removeTextarea(int index)
 {
     removeTextarea(textarea(index));
 }
 
 bool Textlayer::swapTextareas(int swapThis, int withThis)
 {
     if(swapThis > -1 && withThis > -1) {
         d->textareas.swap(swapThis, withThis);
-        emit textareaCountChanged();
+        emit textareaPointStringsChanged();
         return true;
     }
     return false;
 }
 
-int Textlayer::textareaCount()
+QStringList Textlayer::textareaPointStrings()
 {
-    return d->textareas.size();
+    QStringList textAreaList;
+    for (int i=0; i<d->textareas.size(); i++) {
+        QStringList points;
+        for (int p=0; p< textarea(i)->pointCount(); p++) {
+            points.append(QString("%1,%2").arg(textarea(i)->point(p).x()).arg(textarea(i)->point(p).y()));
+        }
+        textAreaList.append(points.join(" "));
+    }
+    return textAreaList;
 }
diff --git a/src/acbf/AcbfTextlayer.h b/src/acbf/AcbfTextlayer.h
index 0f70365..54b3310 100644
--- a/src/acbf/AcbfTextlayer.h
+++ b/src/acbf/AcbfTextlayer.h
@@ -1,150 +1,152 @@
 /*
  * 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef ACBFTEXTLAYER_H
 #define ACBFTEXTLAYER_H
 
 #include <memory>
 
 #include "AcbfPage.h"
 /**
  * \brief Class to handle the textlayer element.
  * 
  * ACBF textlayers are groupings of textareas
  * according to a specific language.
  * 
  * They also have a default textarea background color.
  */
 namespace AdvancedComicBookFormat
 {
 class Textarea;
 class ACBF_EXPORT Textlayer : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QString language READ language WRITE setLanguage NOTIFY languageChanged)
     Q_PROPERTY(QString bgcolor READ bgcolor WRITE setBgcolor NOTIFY bgcolorChanged)
-    Q_PROPERTY(int textareaCount READ textareaCount NOTIFY textareaCountChanged)
+    Q_PROPERTY(QStringList textareaPointStrings READ textareaPointStrings NOTIFY textareaPointStringsChanged)
 public:
     explicit Textlayer(Page* parent = nullptr);
     ~Textlayer() override;
 
     /**
      * \brief Write the textlayer into the xml writer.
      */
     void toXml(QXmlStreamWriter* writer);
     /**
      * \brief load a textlayer element into this object.
      * @return True if the xmlReader encountered no errors.
      */
     bool fromXml(QXmlStreamReader *xmlReader);
 
     /**
      * @returns the language for this text-layer.
      */
     QString language() const;
     /**
      * \brief set the language for this text-layer.
      * @param language - the language of the entry in language code, country
      * code format joined by a dash (not an underscore).
      */
     void setLanguage(const QString& language);
     /**
      * @brief fires when the language changes.
      */
     Q_SIGNAL void languageChanged();
 
     /**
      * @return the background color as a QString.
      * 
      * It should be an 8bit per channel rgb hexcode.
      */
     QString bgcolor() const;
     /**
      * \brief set the background color.
      * 
      * @param newColor - a String with an 8bit per channel rgb hexcode (#ff00ff, or the like)
      */
     void setBgcolor(const QString& newColor = QString());
     /**
      * @brief fires when the background color changes.
      */
     Q_SIGNAL void bgcolorChanged();
 
     /**
      * @returns a list of textareas in this page.
      */
     QList<Textarea*> textareas() const;
     /**
      * @param index - index of the textarea.
      * @return the textarea of that index.
      */
     Q_INVOKABLE Textarea* textarea(int index) const;
     /**
      * @param textarea - the textarea you want to index of.
      * @returns the index of the given textarea.
      */
     Q_INVOKABLE int textareaIndex(Textarea* textarea) const;
 
     /**
      * \brief add a textarea to the list of frames.
      * @param textarea - the textarea to add.
      * @param index - the index to add it at. If afterIndex is larger than
      * zero, the insertion will happen at that index
      */
     void addTextarea(Textarea* textarea, int index = -1);
     /**
      * @brief add a text area at index.
      * @param index - the index to add it at. If afterIndex is larger than
      * zero, the insertion will happen at that index
      */
     Q_INVOKABLE void addTextarea(int index = -1);
     /**
      * \brief remove the given textarea from the framelist.
      * @param textarea - the textarea to remove.
      */
     void removeTextarea(Textarea* textarea);
     /**
      * @brief addTextarea
      * @param index to remove the textarea at.
      */
     Q_INVOKABLE void removeTextarea(int index);
     /**
      * \brief Swap two textareas in the list.
      * @param swapThis - the first textarea to swap.
      * @param withThis - the second textarea to swap.
      */
     Q_INVOKABLE bool swapTextareas(int swapThis, int withThis);
     /**
-     * @brief textareaCount
-     * @return
+     * @brief a list with the textareas.
+     * This is a hack to ensure that qml repeaters and listviews update
+     * properly when the textareas are swapped.
+     * @return a QStringList with textareas and their points.
      */
-    int textareaCount();
+    QStringList textareaPointStrings();
     /**
      * @brief textareaCountChanged
      */
-    Q_SIGNAL void textareaCountChanged();
+    Q_SIGNAL void textareaPointStringsChanged();
 private:
     class Private;
     std::unique_ptr<Private> d;
 };
 }
 
 #endif//ACBFTEXTLAYER_H
diff --git a/src/creator/qml/BookPage.qml b/src/creator/qml/BookPage.qml
index d97f4ab..a633f19 100644
--- a/src/creator/qml/BookPage.qml
+++ b/src/creator/qml/BookPage.qml
@@ -1,272 +1,272 @@
 /*
  * Copyright (C) 2015 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 import QtQuick 2.2
 
 import org.kde.kirigami 2.1 as Kirigami
 /**
  * Page that holds an image to edit the frames on.
  */
 Kirigami.Page {
     id: root;
     property string categoryName: "bookPage";
     title: i18nc("title of the page editing sub-page for the book editor", "Page %1", root.pageTitle === "" ? root.index : root.pageTitle);
     property QtObject model;
     property QtObject currentPage;
     property int index: -1;
     property string pageUrl: "";
     property string pageTitle: "";
     signal save();
 
 
     onIndexChanged: {
         if (root.index===0) {
             root.currentPage = root.model.acbfData.metaData.bookInfo.coverpage();
         } else if (root.index > 0) {
             root.currentPage = root.model.acbfData.body.page(root.index-1);
         }
         root.pageTitle = root.currentPage.title("");
         // Let's ensure there's always a default text-layer.
         if (root.currentPage.textLayerLanguages.length === 0) {
             root.currentPage.addTextLayer("")
         } else if (root.currentPage.textLayerLanguages.indexOf("") < 0) {
             root.currentPage.duplicateTextLayer(root.currentPage.textLayerLanguages[1], "");
         }
     }
 
     actions {
         main: saveAndCloseAction;
         right: editPageDataAction;
     }
     Kirigami.Action {
         id: saveAndCloseAction;
         text: i18nc("Saves the remaining unsaved edited fields and closes the page editor", "Save and Close Page");
         iconName: "dialog-ok";
         shortcut: "Esc";
         onTriggered: {
             root.save();
             root.model.setDirty();
             pageStack.pop();
         }
     }
     Kirigami.Action {
         id: editPageDataAction;
         text: i18nc("Edit the page data in detail", "Edit Page Data");
         iconName: "document-edit"
         onTriggered: pageStack.push(pageInfo)
     }
 
     Image {
         id: coverImage;
         anchors {
             fill: parent;
             margins: Kirigami.Units.smallSpacing;
         }
         asynchronous: true;
         fillMode: Image.PreserveAspectFit;
         source: pageUrl;
         width: root.width;
         height: root.height;
         property real muliplierWidth: (paintedWidth / sourceSize.width);
         property real muliplierHeight: (paintedHeight / sourceSize.height);
         property int offsetX: (width-paintedWidth)/2
         property int offsetY: (height-paintedHeight)/2
 
         Repeater {
-            model: root.currentPage.frameCount
+            model: root.currentPage.framePointStrings
 
             Rectangle {
                 width: coverImage.muliplierWidth * root.currentPage.frame(index).bounds.width;
                 height: coverImage.muliplierHeight * root.currentPage.frame(index).bounds.height;
                 x: coverImage.muliplierWidth * root.currentPage.frame(index).bounds.x + coverImage.offsetX
                 y: coverImage.muliplierHeight * root.currentPage.frame(index).bounds.y + coverImage.offsetY;
                 border.color: "blue";
                 color: "transparent";
                 opacity: 0.5;
                 border.width: Kirigami.Units.smallSpacing;
                 Rectangle {
                     anchors.fill: parent;
                     opacity: 0.4;
                     color: "blue";
                 }
                 Text {
                     text: index+1;
                     anchors {
                         centerIn: parent;
                     }
                     color: "blue";
                     font.weight: Font.Bold;
                 }
             }
         }
 
         Repeater {
-            model: root.currentPage.textLayer("").textareaCount
+            model: root.currentPage.textLayer("").textareaPointStrings
 
             Rectangle {
                 width: coverImage.muliplierWidth * root.currentPage.textLayer("").textarea(index).bounds.width;
                 height: coverImage.muliplierHeight * root.currentPage.textLayer("").textarea(index).bounds.height;
                 x: coverImage.muliplierWidth * root.currentPage.textLayer("").textarea(index).bounds.x + coverImage.offsetX
                 y: coverImage.muliplierHeight * root.currentPage.textLayer("").textarea(index).bounds.y + coverImage.offsetY;
                 border.color: "red";
                 color: "transparent";
                 opacity: 0.5;
                 border.width: Kirigami.Units.smallSpacing;
                 Rectangle {
                     anchors.fill: parent;
                     opacity: 0.4;
                     color: "red";
                 }
                 Text {
                     text: index+1;
                     anchors {
                         centerIn: parent;
                     }
                     color: "red";
                     font.weight: Font.Bold;
                 }
             }
         }
 
         Repeater {
-            model: root.currentPage.jumpCount
+            model: root.currentPage.jumpPointStrings
 
             Rectangle {
                 width: coverImage.muliplierWidth * root.currentPage.jump(index).bounds.width;
                 height: coverImage.muliplierHeight * root.currentPage.jump(index).bounds.height;
                 x: coverImage.muliplierWidth * root.currentPage.jump(index).bounds.x + coverImage.offsetX
                 y: coverImage.muliplierHeight * root.currentPage.jump(index).bounds.y + coverImage.offsetY;
                 border.color: "green";
                 color: "transparent";
                 opacity: 0.5;
                 border.width: Kirigami.Units.smallSpacing;
                 Rectangle {
                     anchors.fill: parent;
                     opacity: 0.4;
                     color: "green";
                 }
                 Text {
                     text: index+1;
                     anchors {
                         centerIn: parent;
                     }
                     color: "green";
                     font.weight: Font.Bold;
                 }
             }
         }
         MouseArea {
             anchors.fill: parent;
             id: pointCatchArea;
             property point startPoint: Qt.point(0,0);
             property point endPoint: Qt.point(0,0);
             property bool dragging: false;
             //hoverEnabled: true;
             preventStealing: true;
 
             onPressed: {
                 if (dragging == false) {
                     startPoint = Qt.point(mouse.x, mouse.y);
                     endPoint = startPoint;
                     dragging = true;
                     mouse.accepted
                 }
 
             }
 
             onPositionChanged: {
                 if (dragging) {
                     endPoint = Qt.point(mouse.x, mouse.y)
                     mouse.accepted
                 }
             }
 
             onReleased: {
                 if (dragging) {
                     if (Qt.point(mouse.x, mouse.y)!==startPoint) {
                         endPoint = Qt.point(mouse.x, mouse.y);
                         dragging = false;
                         createFrame();
                         mouse.accepted
                     }
                 }
 
             }
             onCanceled: {
                 dragging = false;
                 endPoint: Qt.point(0,0);
                 startPoint: Qt.point(0,0);
             }
 
             Rectangle {
                 x: Math.min(parent.startPoint.x, parent.endPoint.x);
                 y: Math.min(parent.startPoint.y, parent.endPoint.y);
                 width: Math.max(parent.startPoint.x, parent.endPoint.x) - Math.min(parent.startPoint.x, parent.endPoint.x);
                 height: Math.max(parent.startPoint.y, parent.endPoint.y) - Math.min(parent.startPoint.y, parent.endPoint.y);
                 opacity: 0.5;
                 border.color: "black";
                 border.width: 1;
             }
 
             function createFrame() {
                 var x  = ( Math.min(startPoint.x, endPoint.x) - coverImage.offsetX ) / coverImage.muliplierWidth;
                 var x2 = ( Math.max(startPoint.x, endPoint.x) - coverImage.offsetX ) / coverImage.muliplierWidth;
                 var y  = ( Math.min(startPoint.y, endPoint.y) - coverImage.offsetY ) / coverImage.muliplierHeight;
                 var y2 = ( Math.max(startPoint.y, endPoint.y) - coverImage.offsetY ) / coverImage.muliplierHeight;
 
                 addPageArea.topLeft = Qt.point(x,y);
                 addPageArea.bottomRight = Qt.point(x2,y2);
                 endPoint = startPoint;
                 addPageArea.open();
             }
 
         }
     }
     Component {
         id: pageInfo;
         PageMetaInfo {
             colorname: root.model.acbfData.body.bgcolor !== ""? root.model.acbfData.body.bgcolor: "#ffffff";
             page: root.currentPage;
             onSave: {root.pageTitle = page.title(""); root.model.setDirty();}
         }
     }
 
     AddPageArea {
         id: addPageArea
         onSave: {
             var index = 0;
             if (type===0) {
-                index = root.currentPage.frameCount;
+                index = root.currentPage.framePointStrings.length;
                 root.currentPage.addFrame(index);
                 root.currentPage.frame(index).setPointsFromRect(topLeft, bottomRight);
             } else if (type===1) {
-                index = root.currentPage.textLayer("").textareaCount;
+                index = root.currentPage.textLayer("").textareaPointStrings.length;
                 root.currentPage.textLayer("").addTextarea(index);
                 root.currentPage.textLayer("").textarea(index).setPointsFromRect(topLeft, bottomRight);
             } else if (type===2) {
-                index = root.currentPage.jumpCount;
+                index = root.currentPage.jumpPointStrings.length;
                 root.currentPage.addJump(index);
                 root.currentPage.jump(index).setPointsFromRect(topLeft, bottomRight);
             }
         }
     }
 
 }
diff --git a/src/creator/qml/PageMetaInfo.qml b/src/creator/qml/PageMetaInfo.qml
index 70ed119..a5c060b 100644
--- a/src/creator/qml/PageMetaInfo.qml
+++ b/src/creator/qml/PageMetaInfo.qml
@@ -1,309 +1,309 @@
 /*
  * Copyright (C) 2018 Wolthera van Hövell tot Westerflier<griffinvalley@gmail.com>
  *
  * 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 import QtQuick 2.2
 import QtQuick.Controls 2.2 as QtControls
 
 import org.kde.kirigami 2.1 as Kirigami
 /**
  * Page that holds an image to edit the frames on.
  */
 import QtQuick 2.0
 
 Kirigami.ScrollablePage {
     id: root;
     title: i18nc("title text for the page meta information editor sheet", "Edit Page Information");
     property QtObject page;
     property string colorname: "#ffffff";
     signal save();
 
     actions {
         main: saveAndCloseAction;
     }
     Kirigami.Action {
         id: saveAndCloseAction;
         text: i18nc("Saves the remaining unsaved edited fields and closes the metainfo editor", "Close Editor");
         iconName: "dialog-ok";
         shortcut: "Esc";
         onTriggered: {
             root.page.setTitle(defaultTitle.text, "")
             root.page.bgcolor = pageBackgroundColor.text;
             root.save();
             pageStack.pop();
         }
     }
 
     Column {
         id: contentColumn;
         width: root.width - (root.leftPadding + root.rightPadding);
         height: childrenRect.height;
         spacing: Kirigami.Units.smallSpacing;
         Kirigami.Heading {
             width: parent.width;
             height: paintedHeight + Kirigami.Units.smallSpacing * 2;
             text: i18nc("label text for the edit field for the page title", "Title");
         }
 
         Item { width: parent.width; height: Kirigami.Units.smallSpacing; }
         QtControls.TextField {
             id: defaultTitle;
             width: parent.width;
             placeholderText: i18nc("placeholder text for default page text-input", "Write to add default title");
             text: root.page.title("");
             onEditingFinished: root.page.setTitle(text, "");
         }
         Kirigami.Heading {
             width: parent.width;
             height: paintedHeight + Kirigami.Units.smallSpacing * 2;
             text: i18nc("label text for the edit field for the page transition type", "Transition");
         }
 
         Item { width: parent.width; height: Kirigami.Units.smallSpacing; }
         QtControls.ComboBox {
             id: transition;
             width: parent.width;
             model: root.page.availableTransitions();
             currentIndex: root.page.transition!==""?
                               root.page.availableTransitions().indexOf(root.page.transition):
                               root.page.availableTransitions().indexOf("none");
             onActivated: root.page.transition = currentText;
         }
         Kirigami.Heading {
             width: parent.width;
             height: paintedHeight + Kirigami.Units.smallSpacing * 2;
             text: i18nc("label text for the edit field for the page background color", "Background Color");
         }
 
         Item { width: parent.width; height: Kirigami.Units.smallSpacing; }
         QtControls.TextField {
             id: pageBackgroundColor;
             width: parent.width;
             placeholderText: root.colorname;
             text: root.page.bgcolor;
             onEditingFinished: root.page.bgcolor = text;
         }
 
         Kirigami.Heading {
             width: parent.width;
             height: paintedHeight + Kirigami.Units.smallSpacing * 2;
             text: i18nc("label text for the edit field for the page frames", "Frames");
         }
         ListView {
             width: parent.width;
             height: childrenRect.height;
-            model: page.frameCount
+            model: page.framePointStrings
             delegate: Kirigami.SwipeListItem {
                 id: frameItem;
                 height: Kirigami.Units.iconSizes.huge + Kirigami.Units.smallSpacing * 2;
                 width: parent.width;
                 supportsMouseEvents: true;
                 actions: [
                     Kirigami.Action {
                         text: i18nc("swap the position of this frame with the previous one", "Move Up");
                         iconName: "go-up"
                         onTriggered: { page.swapFrames(index, index - 1); }
                         enabled: index > 0;
-                        visible: false; //hidden because the listview doesn't update.
+                        visible: enabled;
                     },
                     Kirigami.Action {
                         text: i18nc("swap the position of this frame with the next one", "Move Down");
                         iconName: "go-down"
                         onTriggered: { page.swapFrames(index, index + 1); }
-                        enabled: index < page.frameCount - 1;
-                        visible: false; //hidden because the listview doesn't update.
+                        enabled: index < page.framePointStrings.length - 1;
+                        visible: enabled;
                     },
                     Kirigami.Action {
                         text: i18nc("remove the frame from the page", "Delete Frame");
                         iconName: "list-remove"
                         onTriggered: page.removeFrame(index);
                     }
                 ]
                 Item {
                     anchors.fill: parent;
                     QtControls.Label {
                         id: frameLabel;
                         text: i18nc("Comic book panel frame name.", "Frame %1", index+1);
                     }
                     QtControls.Label {
                         id: frameBgcolorLabel;
                         anchors {
                             top: frameLabel.bottom;
                             topMargin: Kirigami.Units.smallSpacing;
                         }
                         height: frameBgcolor.height;
                         text: i18nc("Label from frame background color.", "Background Color:");
                     }
 
                     QtControls.TextField {
                         anchors {
                             top: frameLabel.bottom;
                             topMargin: Kirigami.Units.smallSpacing;
                             left: frameBgcolorLabel.right;
                             leftMargin: Kirigami.Units.smallSpacing;
                         }
                         id: frameBgcolor;
                         text: page.frame(index).bgcolor;
                         onEditingFinished: page.frame(index).bgcolor = text;
                         placeholderText: pageBackgroundColor.text !== ""? pageBackgroundColor.text : root.colorname;
                     }
                 }
             }
         }
         Kirigami.Heading {
             width: parent.width;
             height: paintedHeight + Kirigami.Units.smallSpacing * 2;
             text: i18nc("label text for the edit field for the page textareas", "Text Areas");
         }
         QtControls.Label {
             id: textLayerBgcolorLabel;
             height: textLayerBgColor.height;
             text: i18nc("Label from textlayer background color.", "Background Color:");
         }
 
         QtControls.TextField {
             anchors {
                 left: textLayerBgcolorLabel.right;
                 leftMargin: Kirigami.Units.smallSpacing;
             }
             id: textLayerBgColor;
             text: page.textLayer("").bgcolor;
             onEditingFinished: page.textLayer("").bgcolor = text;
             placeholderText: pageBackgroundColor.text !== ""? pageBackgroundColor.text : root.colorname;
         }
         ListView {
-            model: page.textLayer("").textareaCount;
+            model: page.textLayer("").textareaPointStrings;
             width: parent.width;
             height: childrenRect.height;
             delegate: Kirigami.SwipeListItem {
                 id: textAreaItem;
                 height: Kirigami.Units.iconSizes.huge + Kirigami.Units.smallSpacing * 2;
                 supportsMouseEvents: true;
                 actions: [
                     Kirigami.Action {
                         text: i18nc("swap the position of this text area with the previous one", "Move Up");
                         iconName: "go-up"
                         onTriggered: { page.textLayer("").swapTextareas(index, index - 1); }
                         enabled: index > 0;
-                        visible: false;
+                        visible: enabled;
                     },
                     Kirigami.Action {
                         text: i18nc("swap the position of this text area with the next one", "Move Down");
                         iconName: "go-down"
                         onTriggered: { page.textLayer("").swapTextareas(index, index + 1); }
-                        enabled: index < page.textLayer("").textareaCount - 1;
-                        visible: false;
+                        enabled: index < page.textLayer("").textareaPointStrings.length - 1;
+                        visible: enabled;
                     },
                     Kirigami.Action {
                         text: i18nc("remove the text area from the page", "Delete Text Area");
                         iconName: "list-remove"
                         onTriggered: page.textLayer("").removeTextarea(index);
                     }
                 ]
                 Item {
                     anchors.fill:parent;
                     QtControls.Label {
                         id: textareaLabel;
                         text: i18nc("Comic book panel textarea name.", "Text Area %1", index+1);
                     }
                     QtControls.TextArea {
                         anchors {
                             top: textareaLabel.bottom;
                             topMargin: Kirigami.Units.smallSpacing;
                         }
                         width:parent.width-Kirigami.Units.iconSizes.huge;
                         text: page.textLayer("").textarea(index).paragraphs.join("\n\n");
                         onEditingFinished: page.textLayer("").textarea(index).paragraphs = text.split("\n\n");
                     }
                 }
             }
         }
         Kirigami.Heading {
             width: parent.width;
             height: paintedHeight + Kirigami.Units.smallSpacing * 2;
             text: i18nc("label text for the edit field for the page jumps", "Jumps");
         }
         ListView {
-            model: page.jumpCount
+            model: page.jumpPointStrings
             width: parent.width;
             height: childrenRect.height;
             delegate: Kirigami.SwipeListItem {
                 id: jumpItem;
                 height: Kirigami.Units.iconSizes.huge + Kirigami.Units.smallSpacing * 2;
                 supportsMouseEvents: true;
                 actions: [
                     Kirigami.Action {
                         text: i18nc("swap the position of this jump with the previous one", "Move Up");
                         iconName: "go-up"
                         onTriggered: { page.swapJumps(index, index - 1); }
                         enabled: index > 0;
-                        visible: false;
+                        visible: enabled;
                     },
                     Kirigami.Action {
                         text: i18nc("swap the position of this jump with the next one", "Move Down");
                         iconName: "go-down"
                         onTriggered: { page.swapJumps(index, index + 1); }
-                        enabled: index < page.jumpCount - 1;
-                        visible: false;
+                        enabled: index < page.jumpPointStrings.length - 1;
+                        visible: enabled;
                     },
                     Kirigami.Action {
                         text: i18nc("remove the jump from the page", "Delete Jump");
                         iconName: "list-remove"
                         onTriggered: page.removeJump(index);
                     }
                 ]
                 Item {
                     anchors.fill:parent;
                     QtControls.Label {
                         id: jumpLabel;
                         text: i18nc("Comic book panel jump name.", "Jump %1", index+1);
                     }
                     QtControls.Label {
                         id: pageIndexLabel;
                         anchors {
                             top: jumpLabel.bottom;
                             topMargin: Kirigami.Units.smallSpacing;
                         }
                         height: jumpIndexSpin.height;
                         text: i18nc("Label from jump page index.", "Page Index:");
                     }
 
                     QtControls.SpinBox {
                         anchors {
                             top: jumpLabel.bottom;
                             topMargin: Kirigami.Units.smallSpacing;
                             left: pageIndexLabel.right;
                             leftMargin: Kirigami.Units.smallSpacing;
                         }
                         from: 0;
                         to: 99;
                         id: jumpIndexSpin;
                         value: page.jump(index).pageIndex;
                         onValueChanged: {
                             if (page.jump(index).pageIndex !== value) {
                                 page.jump(index).pageIndex = value;
                             }
                         }
                     }
                 }
             }
         }
     }
 }