Merge lp:~zsombi/ubuntu-ui-toolkit/bottomEdgePreloadsContent into lp:ubuntu-ui-toolkit/staging

[Zsombor Egri]

BorromEdge.preloadContent

[lp:~zsombi/ubuntu-ui-toolkit/bottomEdgePreloadsContent]

1845. By Zsombor Egri on 2016-02-18

remove original asyncloader

1846. By Zsombor Egri on 2016-02-18

prereq merge

1847. By Zsombor Egri on 2016-02-19

prereq sync

1848. By Zsombor Egri on 2016-02-19

adjust AsyncLoader changes

1849. By Zsombor Egri on 2016-02-19

API updated

1850. By Zsombor Egri on 2016-02-19

remove enum

1851. By Zsombor Egri on 2016-02-19

make things nicer and unified

1852. By Zsombor Egri on 2016-02-19

use BottomEdge context when creating the content

1853. By Zsombor Egri on 2016-02-20

tests added, content handling fixed

1854. By Zsombor Egri on 2016-02-20

adjust tests with deprecation warning so those are not shown anymore

1855. By Zsombor Egri on 2016-02-20

prereq sync

1856. By Zsombor Egri on 2016-02-20

reshape gallery page

1857. By Zsombor Egri on 2016-02-24

prereq sync

1858. By Zsombor Egri on 2016-02-25

prereq sync

1859. By Zsombor Egri on 2016-02-25

turn off logs

1860. By Zsombor Egri on 2016-02-29

prereq sync

1861. By Zsombor Egri on 2016-03-01

prereq sync

Unmerged revisions

=== modified file 'examples/ubuntu-ui-toolkit-gallery/BottomEdgePage.qml'
--- examples/ubuntu-ui-toolkit-gallery/BottomEdgePage.qml	2016-01-13 16:07:58 +0000
+++ examples/ubuntu-ui-toolkit-gallery/BottomEdgePage.qml	2016-02-19 14:39:50 +0000
@@ -119,6 +119,7 @@
             flickable: page.flickable
         }
         contentComponent: bottomEdgeContent
+        preloadContent: true
 
         onCommitCompleted: {
             if (contentToLayout.checked && contentToLayout.enabled) {

=== modified file 'src/Ubuntu/Components/plugin/ucbottomedge.cpp'
--- src/Ubuntu/Components/plugin/ucbottomedge.cpp	2016-01-25 12:23:03 +0000
+++ src/Ubuntu/Components/plugin/ucbottomedge.cpp	2016-02-19 14:39:50 +0000
@@ -37,6 +37,8 @@
 #include "private/ucswipearea_p.h"
 #include <QtQuick/private/qquickanimation_p.h>
 
+using namespace UbuntuToolkit;
+
 Q_LOGGING_CATEGORY(ucBottomEdge, "ubuntu.components.BottomEdge", QtMsgType::QtWarningMsg)
 
 #define LOG     qCDebug(ucBottomEdge) << "[BottomEdge]"
@@ -47,6 +49,7 @@
     , hint(new UCBottomEdgeHint)
     , contentComponent(Q_NULLPTR)
     , bottomPanel(Q_NULLPTR)
+    , loader(Q_NULLPTR)
     , previousDistance(0.0)
     , dragProgress(0.)
     , status(UCBottomEdge::Hidden)
@@ -54,6 +57,7 @@
     , dragDirection(UCBottomEdge::Undefined)
     , defaultRegionsReset(false)
     , mousePressed(false)
+    , preloadContent(false)
 {
 }
 
@@ -1082,4 +1086,58 @@
     return d->activeRegion;
 }
 
+/*!
+ * \qmlproperty bool BottomEdge::preloadContent
+ * If set, all the contents set in the component and in regions will be loaded
+ * in the background, so it will be available before it is revealed.
+ */
+bool UCBottomEdge::preloadContent() const
+{
+    return d_func()->preloadContent;
+}
+void UCBottomEdge::setPreloadContent(bool value)
+{
+    Q_D(UCBottomEdge);
+    if (d->preloadContent == value) {
+        return;
+    }
+    d->preloadContent = value;
+    if (!d->preloadContent) {
+        d->loader->reset();
+    } else {
+        d->preload();
+    }
+
+    // TODO: instruct regions to preload
+    Q_EMIT preloadContentChanged();
+}
+
+void UCBottomEdgePrivate::preload()
+{
+    if (!preloadContent) {
+        return;
+    }
+    Q_Q(UCBottomEdge);
+    if (!loader) {
+        loader = new AsyncLoader(q);
+        QObject::connect(loader, SIGNAL(statusChanged(QQmlIncubator::Status,QObject*)),
+                         q, SLOT(onLoaderStatusChanged(QQmlIncubator::Status,QObject*)));
+    }
+    // component has priority over the URL!
+    if (contentComponent) {
+        loader->load(contentComponent, new QQmlContext(qmlContext(q)));
+    } else if (contentUrl.isValid()) {
+        loader->load(qmlEngine(q), contentUrl, new QQmlContext(qmlContext(q)));
+    }
+}
+
+void UCBottomEdgePrivate::onLoaderStatusChanged(QQmlIncubator::Status status, QObject *object)
+{
+    qDebug() << status << object;
+    if (status == QQmlIncubator::Ready && object) {
+        object->setParent(bottomPanel->m_panel);
+        qobject_cast<QQuickItem*>(object)->setParentItem(bottomPanel->m_panel);
+    }
+}
+
 #include "moc_ucbottomedge.cpp"

=== modified file 'src/Ubuntu/Components/plugin/ucbottomedge.h'
--- src/Ubuntu/Components/plugin/ucbottomedge.h	2015-12-11 12:10:54 +0000
+++ src/Ubuntu/Components/plugin/ucbottomedge.h	2016-02-19 14:39:50 +0000
@@ -42,6 +42,7 @@
     Q_PROPERTY(QQuickItem* contentItem READ contentItem NOTIFY contentItemChanged FINAL)
     Q_PROPERTY(QQmlListProperty<UCBottomEdgeRegion> regions READ regions NOTIFY regionsChanged FINAL)
     Q_PROPERTY(UCBottomEdgeRegion* activeRegion READ activeRegion NOTIFY activeRegionChanged FINAL)
+    Q_PROPERTY(bool preloadContent READ preloadContent WRITE setPreloadContent NOTIFY preloadContentChanged FINAL DESIGNABLE false)
 
     // overloaded data property to catch regions
     Q_PRIVATE_PROPERTY(UCBottomEdge::d_func(), QQmlListProperty<QObject> data READ data DESIGNABLE false)
@@ -73,6 +74,8 @@
     void setFillWindow(bool fill);
     QQmlListProperty<UCBottomEdgeRegion> regions();
     UCBottomEdgeRegion *activeRegion();
+    bool preloadContent() const;
+    void setPreloadContent(bool value);
 
 Q_SIGNALS:
     void dragProgressChanged(qreal dragProgress);
@@ -83,6 +86,7 @@
     void contentItemChanged();
     void regionsChanged();
     void activeRegionChanged(UCBottomEdgeRegion *activeRegion);
+    void preloadContentChanged();
 
     void commitStarted();
     void commitCompleted();
@@ -109,6 +113,9 @@
 
     Q_DECLARE_PRIVATE(UCBottomEdge)
 
+private:
+    Q_PRIVATE_SLOT(d_func(), void onLoaderStatusChanged(QQmlIncubator::Status status, QObject *object))
+
     friend class tst_BottomEdge;
 };
 Q_DECLARE_METATYPE(UCBottomEdge::Status)

=== modified file 'src/Ubuntu/Components/plugin/ucbottomedge_p.h'
--- src/Ubuntu/Components/plugin/ucbottomedge_p.h	2015-12-21 17:49:59 +0000
+++ src/Ubuntu/Components/plugin/ucbottomedge_p.h	2016-02-19 14:39:50 +0000
@@ -23,6 +23,10 @@
 #include "ucstyleditembase_p.h"
 #include "ucaction.h"
 
+#include <AsyncLoader>
+
+using namespace UbuntuToolkit;
+
 class UCBottomEdgeStyle;
 class UCBottomEdgePrivate : public UCStyledItemBasePrivate, protected QQuickItemChangeListener
 {
@@ -70,6 +74,9 @@
     void itemChildAdded(QQuickItem *item, QQuickItem *child);
     void itemChildRemoved(QQuickItem *item, QQuickItem *child);
 
+    void preload();
+    void onLoaderStatusChanged(QQmlIncubator::Status status, QObject *object);
+
     // members
     QUrl contentUrl;
     QList<UCBottomEdgeRegion*> regions;
@@ -77,6 +84,7 @@
     UCBottomEdgeHint *hint;
     QQmlComponent *contentComponent;
     UCBottomEdgeStyle *bottomPanel;
+    UbuntuToolkit::AsyncLoader *loader;
 
     qreal previousDistance;
     qreal dragProgress;
@@ -93,6 +101,7 @@
 
     bool defaultRegionsReset:1;
     bool mousePressed:1;
+    bool preloadContent:1;
 
     // status management
     void setOperationStatus(OperationStatus s);

=== modified file 'src/Ubuntu/Test/plugin/uctestcase.cpp'
--- src/Ubuntu/Test/plugin/uctestcase.cpp	2016-01-25 17:12:56 +0000
+++ src/Ubuntu/Test/plugin/uctestcase.cpp	2016-02-19 14:39:50 +0000
@@ -76,3 +76,16 @@
         QTest::ignoreMessage(QtWarningMsg, warning.toUtf8());
     }
 }
+
+/*!
+ * Same as previous but without column number
+ */
+void UbuntuTestCase::ignoreWarning(const QString& fileName, uint line,
+    const QString& message, uint occurences)
+{
+    for (uint i = 0; i < occurences; i++) {
+        QString url(QUrl::fromLocalFile(QFileInfo(fileName).absoluteFilePath()).toEncoded());
+        QString warning(QString("%1:%2 %3").arg(url).arg(line).arg(message));
+        QTest::ignoreMessage(QtWarningMsg, warning.toUtf8());
+    }
+}

=== modified file 'src/Ubuntu/Test/plugin/uctestcase.h'
--- src/Ubuntu/Test/plugin/uctestcase.h	2016-01-25 17:12:56 +0000
+++ src/Ubuntu/Test/plugin/uctestcase.h	2016-02-19 14:39:50 +0000
@@ -54,6 +54,7 @@
     }
 
     static void ignoreWarning(const QString& fileName, uint line, uint column, const QString& message, uint occurences=1);
+    static void ignoreWarning(const QString& fileName, uint line, const QString& message, uint occurences=1);
 
     static inline void waitForSignal(QSignalSpy *spy, int timeout = 5000)
     {

=== modified file 'src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro'
--- src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-02-11 17:19:48 +0000
+++ src/Ubuntu/UbuntuToolkit/UbuntuToolkit.pro	2016-02-19 14:39:50 +0000
@@ -15,8 +15,10 @@
 HEADERS += \ 
     colorutils.h \
     ubuntutoolkitglobal.h \
-    tree.h
+    tree.h \
+    asyncloader.h
 
 SOURCES += \ 
     colorutils.cpp \
-    tree.cpp
+    tree.cpp \
+    asyncloader.cpp

=== added file 'src/Ubuntu/UbuntuToolkit/asyncloader.cpp'
--- src/Ubuntu/UbuntuToolkit/asyncloader.cpp	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/asyncloader.cpp	2016-02-19 14:39:50 +0000
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <asyncloader.h>
+
+#include <QtQml/QQmlContext>
+#include <QtQml/QQmlComponent>
+#include <QtQuick/QQuickItem>
+
+namespace UbuntuToolkit {
+
+AsyncLoader::AsyncLoader(QObject *parent)
+    : QObject(parent)
+    , QQmlIncubator(Asynchronous)
+    , m_component(nullptr)
+    , m_context(nullptr)
+    , m_ownComponent(false)
+{    
+}
+
+AsyncLoader::~AsyncLoader()
+{
+    reset();
+}
+
+// incubator methods
+void AsyncLoader::setInitialState(QObject *object)
+{
+    emitStatus(Initializing, object);
+}
+
+AsyncLoader::LoadingStatus incubatorToLoadingStatus(QQmlIncubator::Status status)
+{
+    switch (status) {
+    case QQmlIncubator::Null: return AsyncLoader::Null;
+    case QQmlIncubator::Ready: return AsyncLoader::Ready;
+    case QQmlIncubator::Loading: return AsyncLoader::Loading;
+    case QQmlIncubator::Error: return AsyncLoader::Error;
+    }
+    // unlikely to be reached, but must satisfy compiler
+    return AsyncLoader::Null;
+}
+
+void AsyncLoader::statusChanged(Status status)
+{
+    if (status == QQmlIncubator::Error) {
+        QList<QQmlError> e = errors();
+        for (int i = 0; i < e.size(); i++) {
+            // remove quotes and any leading/trailing whitespace
+            qWarning().noquote() << e[0].toString().trimmed();
+        }
+    }
+    if (status != QQmlIncubator::Loading) {
+        detachComponent();
+    }
+    // we should emit the status change only after we do the cleanup
+    emitStatus(incubatorToLoadingStatus(status));
+}
+
+// procected methods
+void AsyncLoader::emitStatus(LoadingStatus status, QObject *object)
+{
+    if (m_status == status) {
+        return;
+    }
+
+    m_status = status;
+    if (!object) {
+        object = this->object();
+    }
+    Q_EMIT loadingStatus(m_status, object);
+}
+
+void AsyncLoader::detachComponent()
+{
+    if (!m_component) {
+        return;
+    }
+
+    disconnect(m_component, &QQmlComponent::statusChanged,
+               this, &AsyncLoader::onComponentStatusChanged);
+    if (m_ownComponent) {
+        m_component->deleteLater();
+    }
+    m_component = nullptr;
+    m_ownComponent = false;
+}
+
+void AsyncLoader::onComponentStatusChanged(QQmlComponent::Status status)
+{
+    if (status == QQmlComponent::Error) {
+        QString error = m_component->errorString();
+        // remove quotes and any leading/trailing whitespace
+        qWarning().noquote() << error.trimmed();
+        detachComponent();
+        emitStatus(Error);
+        return;
+    }
+    if (status == QQmlComponent::Ready) {
+        m_component->create(*this, m_context);
+    }
+}
+
+/*!
+ * \brief AsyncLoader::load
+ * \param url
+ * \param context
+ * \return bool
+ * The method initiates the loading of a given \e url within a specific \e context.
+ * Returns true on success.
+ * \note If the loading is initiated while there is a previous loading in place,
+ * you must make sure you delete the object from the previous loading before you
+ * trigger the new load.
+ */
+bool AsyncLoader::load(const QUrl &url, QQmlContext *context)
+{
+    if (!reset()) {
+        return false;
+    }
+    if (url.isEmpty() || !url.isValid() || !context) {
+        emitStatus(Ready);
+        return true;
+    }
+    m_ownComponent = true;
+    return load(new QQmlComponent(context->engine(), url, QQmlComponent::Asynchronous), context);
+}
+
+/*!
+ * \brief AsyncLoader::load
+ * \param component
+ * \param context
+ * \return bool
+ * The method initiates the loading of a \e component within the given \e context.
+ * Returns true on success.
+ * \note If the loading is initiated while there is a previous loading in place,
+ * you must make sure you delete the object from the previous loading before you
+ * trigger the new load.
+ */
+bool AsyncLoader::load(QQmlComponent *component, QQmlContext *context)
+{
+    if (!reset()) {
+        return false;
+    }
+    if (!component || !context) {
+        emitStatus(Ready);
+        return true;
+    }
+    m_component = component;
+    m_context = context;
+    if (m_component->isLoading()) {
+        emitStatus(Compiling);
+        connect(m_component, &QQmlComponent::statusChanged,
+                this, &AsyncLoader::onComponentStatusChanged, Qt::DirectConnection);
+    } else {
+        onComponentStatusChanged(m_component->status());
+    }
+    return true;
+}
+
+/*!
+ * \brief AsyncLoader::reset
+ * \return bool
+ * Clears the incubator and emits loadingStatus() signal with \c Reset status.
+ * The loader can be reset only if the status passed \c Loading. Returns true
+ * if the reset was successful, or when the loader status is \c Ready or
+ * \c Error.
+ */
+bool AsyncLoader::reset()
+{
+    if (m_status < Loading) {
+        return false;
+    }
+    if (m_status >= Ready) {
+        return true;
+    }
+    clear();
+    // make sure the listeners are getting the reset so they can delete the object
+    emitStatus(Reset);
+    return true;
+}
+
+/*!
+ * \brief AsyncLoader::status
+ * \return LoadingStatus
+ * Returns the status of the loader.
+ */
+AsyncLoader::LoadingStatus AsyncLoader::status()
+{
+    return m_status;
+}
+
+/*!
+ * \brief AsyncLoader::forceCompletion
+ * Forces loading completion.
+ */
+void AsyncLoader::forceCompletion()
+{
+    QQmlIncubator::forceCompletion();
+}
+
+} // namespace UbuntuToolkit

=== added file 'src/Ubuntu/UbuntuToolkit/asyncloader.h'
--- src/Ubuntu/UbuntuToolkit/asyncloader.h	1970-01-01 00:00:00 +0000
+++ src/Ubuntu/UbuntuToolkit/asyncloader.h	2016-02-19 14:39:50 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ASYNCLOADER_H
+#define ASYNCLOADER_H
+
+#include <QtQml/QQmlIncubator>
+#include <QtQml/QQmlComponent>
+#include <ubuntutoolkitglobal.h>
+
+class QQuickItem;
+class QQmlContext;
+
+namespace UbuntuToolkit {
+
+class UBUNTUTOOLKIT_EXPORT AsyncLoader : public QObject, protected QQmlIncubator
+{
+    Q_OBJECT
+public:
+    enum LoadingStatus {
+        Null,
+        Compiling,
+        Loading,
+        Initializing,
+        Ready,
+        Error,
+        Reset
+    };
+
+    explicit AsyncLoader(QObject *parent = 0);
+    ~AsyncLoader();
+
+    bool load(const QUrl &url, QQmlContext *context);
+    bool load(QQmlComponent *component, QQmlContext *context);
+    bool reset();
+    LoadingStatus status();
+    void forceCompletion();
+
+Q_SIGNALS:
+    void loadingStatus(LoadingStatus status, QObject *object);
+
+protected:
+    void setInitialState(QObject *object) override;
+    void statusChanged(Status status) override;
+
+    void emitStatus(LoadingStatus status, QObject *object = 0);
+    void onComponentStatusChanged(QQmlComponent::Status status);
+    void detachComponent();
+
+    QQmlComponent *m_component = nullptr;
+    QQmlContext *m_context = nullptr;
+    LoadingStatus m_status = Ready;
+    bool m_ownComponent = false;
+};
+
+} // namespace UbuntuToolkit
+
+#endif // ASYNCLOADER_H

=== modified file 'tests/unit/plugin_dependency.pri'
--- tests/unit/plugin_dependency.pri	2015-12-21 12:18:50 +0000
+++ tests/unit/plugin_dependency.pri	2016-02-19 14:39:50 +0000
@@ -9,6 +9,7 @@
 LIBS += -L$$PLUGIN_BLD/Components -lUbuntuComponents
 LIBS += -L$$PLUGIN_BLD/Test -lUbuntuTest
 LIBS += -L$${ROOT_BUILD_DIR}/lib -lUbuntuGestures
+#LIBS += -L$${ROOT_BUILD_DIR}/lib -lUbuntuToolkit
 DEFINES += QUICK_TEST_SOURCE_DIR=\"\\\"$$_PRO_FILE_PWD_\\\"\"
 QMAKE_CXXFLAGS += -Werror
 

=== modified file 'tests/unit/test-include.pri'
--- tests/unit/test-include.pri	2014-11-25 09:58:33 +0000
+++ tests/unit/test-include.pri	2016-02-19 14:39:50 +0000
@@ -3,6 +3,6 @@
 
 TEMPLATE = app
 QT += testlib qml quick
-CONFIG += no_keywords
+CONFIG += no_keywords c++11
 
 

=== added directory 'tests/unit_x11/tst_asyncloader'
=== added file 'tests/unit_x11/tst_asyncloader/Document.qml'
--- tests/unit_x11/tst_asyncloader/Document.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_asyncloader/Document.qml	2016-02-19 14:39:50 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+
+Column {
+    anchors.fill: parent
+    spacing: 1
+    Repeater {
+        model: 500
+        TextField {
+            width: parent.width
+        }
+    }
+}
+

=== added file 'tests/unit_x11/tst_asyncloader/FaultyDocument.qml'
--- tests/unit_x11/tst_asyncloader/FaultyDocument.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_asyncloader/FaultyDocument.qml	2016-02-19 14:39:50 +0000
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+import QtQuick 2.4
+
+Label {}

=== added file 'tests/unit_x11/tst_asyncloader/HeavyDocument.qml'
--- tests/unit_x11/tst_asyncloader/HeavyDocument.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_asyncloader/HeavyDocument.qml	2016-02-19 14:39:50 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+
+Column {
+    anchors.fill: parent
+    spacing: units.dp(1)
+    Repeater {
+        model: 500
+        TextField {
+            width: parent.width
+        }
+    }
+}
+

=== added file 'tests/unit_x11/tst_asyncloader/TestApp.qml'
--- tests/unit_x11/tst_asyncloader/TestApp.qml	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_asyncloader/TestApp.qml	2016-02-19 14:39:50 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+import QtQuick 2.4
+//import Ubuntu.Components 1.3
+
+//MainView {
+//    width: units.gu(40)
+//    height: units.gu(71)
+
+//    applicationName: "Document"
+//}
+
+Item {
+
+}

=== added file 'tests/unit_x11/tst_asyncloader/tst_asyncloader.cpp'
--- tests/unit_x11/tst_asyncloader/tst_asyncloader.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_asyncloader/tst_asyncloader.cpp	2016-02-19 14:39:50 +0000
@@ -0,0 +1,265 @@
+/*
+ * Copyright 2016 Canonical Ltd.
+ *
+ * This program 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; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include <QtTest/QtTest>
+#include "uctestcase.h"
+#include "uctestextras.h"
+#include <AsyncLoader>
+#include <functional>
+#include <QtQml/QQmlEngine>
+
+class LoaderSpy : public QObject
+{
+    Q_OBJECT
+public:
+    UbuntuToolkit::AsyncLoader *m_loader;
+    QScopedPointer<QObject> m_object;
+    bool m_done = false;
+    bool m_error = false;
+    QList<UbuntuToolkit::AsyncLoader::LoadingStatus> m_statusList;
+public:
+    LoaderSpy(UbuntuToolkit::AsyncLoader *loader)
+        : QObject(0)
+        , m_loader(loader)
+    {
+        connect(loader, &UbuntuToolkit::AsyncLoader::loadingStatus,
+                this, &LoaderSpy::onLoadingStatusChanged);
+    }
+
+protected Q_SLOTS:
+    virtual void onLoadingStatusChanged(UbuntuToolkit::AsyncLoader::LoadingStatus status, QObject *object)
+    {
+        m_statusList << status;
+        if (status == UbuntuToolkit::AsyncLoader::Ready) {
+            m_done = true;
+            m_object.reset(object);
+        }
+        if (status == UbuntuToolkit::AsyncLoader::Error) {
+            m_error = true;
+        }
+    }
+};
+
+class ResetLoaderSpy : public LoaderSpy
+{
+    Q_OBJECT
+public:
+    bool m_reset = false;
+public:
+    ResetLoaderSpy(UbuntuToolkit::AsyncLoader *loader)
+        : LoaderSpy(loader)
+    {
+    }
+
+    void onLoadingStatusChanged(UbuntuToolkit::AsyncLoader::LoadingStatus status, QObject *object) override
+    {
+        if (status == UbuntuToolkit::AsyncLoader::Loading) {
+            m_loader->reset();
+            m_reset = true;
+        }
+        LoaderSpy::onLoadingStatusChanged(status, object);
+    }
+};
+
+class SecondLoaderSpy : public LoaderSpy
+{
+    Q_OBJECT
+public:
+    bool m_loadResult = false;
+public:
+    SecondLoaderSpy(UbuntuToolkit::AsyncLoader *loader, UbuntuToolkit::AsyncLoader::LoadingStatus loadAt,
+                    const QUrl &url, QQmlContext *context)
+        : LoaderSpy(loader)
+        , m_loadAt(loadAt)
+        , m_url(url)
+        , m_context(context)
+    {
+    }
+
+    void onLoadingStatusChanged(UbuntuToolkit::AsyncLoader::LoadingStatus status, QObject *object) override
+    {
+        if (status == (UbuntuToolkit::AsyncLoader::LoadingStatus)m_loadAt) {
+            m_loadAt = -1;
+            delete object;
+            object = nullptr;
+            m_loadResult = m_loader->load(m_url, m_context);
+        }
+        LoaderSpy::onLoadingStatusChanged(status, object);
+    }
+
+private:
+    int m_loadAt;
+    QUrl m_url;
+    QQmlContext *m_context;
+};
+
+/********************************************************************
+ * Test
+ ********************************************************************/
+class tst_AsyncLoader : public QObject
+{
+    Q_OBJECT
+private Q_SLOTS:
+
+    void test_load_data()
+    {
+        QTest::addColumn<bool>("loadAsDocument");
+        QTest::addColumn<QString>("document");
+        QTest::addColumn<int>("mode");
+        QTest::addColumn< QList<int> >("statuses");
+
+        QTest::newRow("document") << true << "Document.qml" << (int)QQmlComponent::Asynchronous
+                                  << (QList<int>()
+                                      << UbuntuToolkit::AsyncLoader::Compiling
+                                      << UbuntuToolkit::AsyncLoader::Loading
+                                      << UbuntuToolkit::AsyncLoader::Initializing
+                                      << UbuntuToolkit::AsyncLoader::Ready
+                                      );
+        QTest::newRow("component, asynchronous") << false << "Document.qml" << (int)QQmlComponent::Asynchronous
+                                                 << (QList<int>()
+                                                     << UbuntuToolkit::AsyncLoader::Compiling
+                                                     << UbuntuToolkit::AsyncLoader::Loading
+                                                     << UbuntuToolkit::AsyncLoader::Initializing
+                                                     << UbuntuToolkit::AsyncLoader::Ready
+                                                     );
+        QTest::newRow("component, synchronous") << false << "Document.qml" << (int)QQmlComponent::PreferSynchronous
+                                                << (QList<int>()
+                                                    << UbuntuToolkit::AsyncLoader::Loading
+                                                    << UbuntuToolkit::AsyncLoader::Initializing
+                                                    << UbuntuToolkit::AsyncLoader::Ready
+                                                    );
+    }
+    void test_load()
+    {
+        QFETCH(bool, loadAsDocument);
+        QFETCH(QString, document);
+        QFETCH(int, mode);
+        QFETCH(QList<int>, statuses);
+
+        QScopedPointer<UbuntuTestCase> view(new UbuntuTestCase("TestApp.qml"));
+        UbuntuToolkit::AsyncLoader loader;
+        LoaderSpy spy(&loader);
+        QScopedPointer<QQmlComponent> component;
+
+        if (loadAsDocument) {
+            loader.load(QUrl::fromLocalFile(document), view->rootContext());
+        } else {
+            // create a component
+            component.reset(new QQmlComponent(view->engine(), QUrl::fromLocalFile(document), (QQmlComponent::CompilationMode)mode));
+            loader.load(component.data(), view->rootContext());
+        }
+        QTRY_VERIFY_WITH_TIMEOUT(spy.m_object != nullptr, 2000);
+        // check the statuses
+        QCOMPARE(spy.m_statusList.length(), statuses.length());
+        for (int i = 0; i < spy.m_statusList.length(); i++) {
+            QVERIFY2((int)spy.m_statusList[i] == statuses[i], (QString(" Status at index %1 differs").arg(i)).toLocal8Bit().constData());
+        }
+    }
+
+    void test_load_with_error()
+    {
+        QUrl document = QUrl::fromLocalFile("FaultyDocument.qml");
+        UbuntuTestCase::ignoreWarning("FaultyDocument.qml", 20, "Label is not a type");
+        QScopedPointer<UbuntuTestCase> view(new UbuntuTestCase("TestApp.qml"));
+        UbuntuToolkit::AsyncLoader loader;
+        LoaderSpy spy(&loader);
+        loader.load(document, view->rootContext());
+        QTRY_VERIFY_WITH_TIMEOUT(spy.m_error == true, 2000);
+    }
+
+    void test_load_and_cancel_data()
+    {
+        QTest::addColumn<bool>("loadAsDocument");
+        QTest::addColumn<QString>("document");
+        QTest::addColumn<int>("mode");
+
+        QTest::newRow("document") << true << "HeavyDocument.qml" << (int)QQmlComponent::Asynchronous;
+        QTest::newRow("component, asynchronous") << false << "HeavyDocument.qml" << (int)QQmlComponent::Asynchronous;
+        QTest::newRow("component, synchronous") << false << "HeavyDocument.qml" << (int)QQmlComponent::PreferSynchronous;
+    }
+    void test_load_and_cancel()
+    {
+        QFETCH(bool, loadAsDocument);
+        QFETCH(QString, document);
+        QFETCH(int, mode);
+
+        QScopedPointer<UbuntuTestCase> view(new UbuntuTestCase("TestApp.qml"));
+        UbuntuToolkit::AsyncLoader loader;
+        ResetLoaderSpy spy(&loader);
+        QScopedPointer<QQmlComponent> component;
+
+        if (loadAsDocument) {
+            loader.load(QUrl::fromLocalFile(document), view->rootContext());
+        } else {
+            // create a component
+            component.reset(new QQmlComponent(view->engine(), QUrl::fromLocalFile(document), (QQmlComponent::CompilationMode)mode));
+            loader.load(component.data(), view->rootContext());
+        }
+        if (loader.status() < UbuntuToolkit::AsyncLoader::Loading) {
+            // cannot reset yet!
+            QVERIFY(!loader.reset());
+        }
+        QTRY_VERIFY_WITH_TIMEOUT(spy.m_reset, 2000);
+    }
+
+    void test_second_load_scenarios_data()
+    {
+        QTest::addColumn<QString> ("doc1");
+        QTest::addColumn<QString> ("doc2");
+        QTest::addColumn<int> ("when");
+        QTest::addColumn<bool> ("success");
+
+        QTest::newRow("status = Compiling")
+                << "Document.qml" << "HeavyDocument.qml"
+                << (int)UbuntuToolkit::AsyncLoader::Compiling << false;
+        QTest::newRow("status = Loading")
+                << "Document.qml" << "HeavyDocument.qml"
+                << (int)UbuntuToolkit::AsyncLoader::Loading << true;
+        QTest::newRow("status = Initializing")
+                << "Document.qml" << "HeavyDocument.qml"
+                << (int)UbuntuToolkit::AsyncLoader::Initializing << true;
+        QTest::newRow("status = Ready")
+                << "Document.qml" << "HeavyDocument.qml"
+                << (int)UbuntuToolkit::AsyncLoader::Ready << true;
+        QTest::newRow("status = Error")
+                << "FaultyDocument.qml" << "HeavyDocument.qml"
+                << (int)UbuntuToolkit::AsyncLoader::Error << true;
+    }
+    void test_second_load_scenarios()
+    {
+        QFETCH(QString, doc1);
+        QFETCH(QString, doc2);
+        QFETCH(int, when);
+        QFETCH(bool, success);
+
+        QScopedPointer<UbuntuTestCase> view(new UbuntuTestCase("TestApp.qml"));
+        UbuntuToolkit::AsyncLoader loader;
+        if (when == (int)UbuntuToolkit::AsyncLoader::Error) {
+            UbuntuTestCase::ignoreWarning("FaultyDocument.qml", 20, "Label is not a type");
+        }
+
+        SecondLoaderSpy spy(&loader, (UbuntuToolkit::AsyncLoader::LoadingStatus)when, QUrl::fromLocalFile(doc2), view->rootContext());
+        // load the first document
+        QVERIFY(loader.load(QUrl::fromLocalFile(doc1), view->rootContext()));
+        QTRY_VERIFY_WITH_TIMEOUT(spy.m_object != nullptr, 4000);
+        QCOMPARE(spy.m_loadResult, success);
+    }
+};
+
+QTEST_MAIN(tst_AsyncLoader)
+
+#include "tst_asyncloader.moc"

=== added file 'tests/unit_x11/tst_asyncloader/tst_asyncloader.pro'
--- tests/unit_x11/tst_asyncloader/tst_asyncloader.pro	1970-01-01 00:00:00 +0000
+++ tests/unit_x11/tst_asyncloader/tst_asyncloader.pro	2016-02-19 14:39:50 +0000
@@ -0,0 +1,11 @@
+include(../test-include.pri)
+QT += core-private qml-private quick-private gui-private UbuntuToolkit
+
+SOURCES += \
+    tst_asyncloader.cpp
+
+DISTFILES += \
+    Document.qml \
+    TestApp.qml \
+    HeavyDocument.qml \
+    FaultyDocument.qml

=== modified file 'tests/unit_x11/tst_bottomedge/tst_bottomedge.cpp'
--- tests/unit_x11/tst_bottomedge/tst_bottomedge.cpp	2016-02-10 10:57:20 +0000
+++ tests/unit_x11/tst_bottomedge/tst_bottomedge.cpp	2016-02-19 14:39:50 +0000
@@ -137,6 +137,7 @@
         QCOMPARE(test->regionAt("testItem", 0)->m_from, 0.33);
         QCOMPARE(test->regionAt("testItem", 0)->m_to, 1.0);
         QVERIFY(!test->testItem()->activeRegion());
+        QVERIFY(!test->testItem()->preloadContent());
     }
 
     void test_height_moves_when_reparented()

=== modified file 'tests/unit_x11/unit_x11.pro'
--- tests/unit_x11/unit_x11.pro	2015-11-23 16:12:16 +0000
+++ tests/unit_x11/unit_x11.pro	2016-02-19 14:39:50 +0000
@@ -17,4 +17,5 @@
     tst_subtheming \
     tst_swipearea \
     tst_touchregistry \
-    tst_bottomedge
+    tst_bottomedge \
+    tst_asyncloader