Merge lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom into lp:ubuntu-docviewer-app/trunk

[Stefano Verzegnassi]

Enable zoom in PDF view & multithreading support

Enabled multithreading support (ImageProvider). At the moment is a bit "ugly" workaround, but it's necessary in order to have good performance with larger documents.

Added VerticalView class, instead of using a ListView. This allows us to have the advantages of a ListView (e.g. cacheBuffer) with a Flickable that can scroll in both directions.
The C++ class comes from Unity 8 (some code has been removed - around 500 lines - and some added).

By doing this, we can provide zoom with good performance.

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

75. By Stefano Verzegnassi on 2015-01-30

Fixed an error while importing new code in PdfView

76. By Stefano Verzegnassi on 2015-01-30

Increment version number

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:74
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/136/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/912/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/912/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/39

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/136/rebuild

review: Needs Fixing (continuous-integration)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:76
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/138/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/915/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/915/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/41

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/138/rebuild

review: Needs Fixing (continuous-integration)

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

77. By Stefano Verzegnassi on 2015-01-31

Fix broken package

78. By Stefano Verzegnassi on 2015-01-31

Revert previous commit, try to fix deb package

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:78
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/140/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/927/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/927/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/43

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/140/rebuild

review: Needs Fixing (continuous-integration)

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

79. By Stefano Verzegnassi on 2015-02-02

Reduce PdfView cachebuffer by half

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:79
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/141/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/932/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/932/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/44

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/141/rebuild

review: Needs Fixing (continuous-integration)

[Riccardo Padovani (rpadovani)]

Tested on vivid desktop, works well.

The workaround about the multithreading is simple and clever (but I hope they fix the bug upstream).

I took a look to code about Flickable, seems good, but I don't have the ability to understand it in its entirety. Anyway, works well.

Thanks for the huge work!

review: Approve

[Stefano Verzegnassi (verzegnassi-stefano)]

Thank you for the review, Riccardo!
Just waiting for fixing a bug about Debian packaging, and it will land soon (I hope) :D

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

80. By Stefano Verzegnassi on 2015-02-03

Merge with trunk - Updated pot

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:80
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/146/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/966/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/966/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/49

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/146/rebuild

review: Needs Fixing (continuous-integration)

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

81. By Stefano Verzegnassi on 2015-02-04

Merge with trunk - solved conflict in debian/control

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:81
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/150/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/986/console
    FAILURE: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/53/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/150/rebuild

review: Needs Fixing (continuous-integration)

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

82. By Stefano Verzegnassi on 2015-02-04

Any comma is important, thank you Jenkins for such lesson

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:82
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/152/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/988/console
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/988/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/55

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/152/rebuild

review: Needs Fixing (continuous-integration)

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

83. By Stefano Verzegnassi on 2015-02-04

Fixed broken debian package building

84. By Stefano Verzegnassi on 2015-02-04

Fixed broken autopilot tests

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:84
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/158/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/994
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/994/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/61

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/158/rebuild

review: Needs Fixing (continuous-integration)

[lp:~verzegnassi-stefano/ubuntu-docviewer-app/20-enable-zoom]

85. By Stefano Verzegnassi on 2015-02-04

Fixed last bits of autopilot test

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:85
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/160/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-vivid/996
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/996/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-docviewer-app-vivid-amd64-ci/63

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-docviewer-app-ci/160/rebuild

review: Approve (continuous-integration)

=== modified file 'README'
--- README	2014-11-02 23:11:07 +0000
+++ README	2015-02-04 14:35:20 +0000
@@ -10,8 +10,11 @@
 Install poppler's development files:
 sudo apt-get install libpoppler-qt5-dev
 
+Install Qt5 private development files:
+sudo apt-get install qtdeclarative5-private-dev qtbase5-private-dev
+
 If you want to compile an arm click package, you need to install that package to the arm compilation environment. For example when using QtCreator for Ubuntu Touch, open Options -> Ubuntu -> Maintain, and then enter:
 
-apt-get install libpoppler-qt5-dev:armhf
+apt-get install libpoppler-qt5-dev:armhf qtdeclarative5-private-dev:armhf qtbase5-private-dev:armhf
 
 

=== modified file 'debian/changelog'
--- debian/changelog	2015-02-04 09:32:00 +0000
+++ debian/changelog	2015-02-04 14:35:20 +0000
@@ -1,3 +1,9 @@
+ubuntu-docviewer-app (0.2.0) utopic; urgency=medium
+
+  * Enabled zoom in the PDF viewer
+
+ -- Stefano <[e-mail]>  Fri, 30 Jan 2015 20:56:08 +0100
+
 ubuntu-docviewer-app (0.1.2) UNRELEASED; urgency=medium
 
   * 

=== modified file 'debian/control'
--- debian/control	2015-02-04 09:32:00 +0000
+++ debian/control	2015-02-04 14:35:20 +0000
@@ -15,6 +15,8 @@
                qtdeclarative5-dev,
                qtdeclarative5-dev-tools,
                qtdeclarative5-qtquick2-plugin,
+               qtdeclarative5-private-dev,
+               qtbase5-private-dev,
                qtdeclarative5-test-plugin
 Standards-Version: 3.9.6
 Section: misc
@@ -24,9 +26,9 @@
 Package: ubuntu-docviewer-app
 Architecture: any
 Depends: qtdeclarative5-qtquick2-plugin,
-         qtdeclarative5-ubuntu-ui-toolkit-plugin | qt-components-ubuntu,
-         ${misc:Depends},
-         ${shlibs:Depends}
+         qtdeclarative5-ubuntu-ui-toolkit-plugin,
+         qtdeclarative5-ubuntu-content1,
+         ${misc:Depends}
 Description: Document Viewer application
  Core Document Viewer application
 

=== modified file 'manifest.json.in'
--- manifest.json.in	2015-01-21 15:41:42 +0000
+++ manifest.json.in	2015-02-04 14:35:20 +0000
@@ -12,7 +12,7 @@
         "content-hub": "docviewer-content.json"
         }
     },
-    "version": "0.1.@BZR_REVNO@",
+    "version": "0.2.@BZR_REVNO@",
     "maintainer": "Ubuntu App Cats <[e-mail]>",
     "x-source": {
         "vcs-bzr": "@BZR_SOURCE@",

=== modified file 'po/com.ubuntu.docviewer.pot'
--- po/com.ubuntu.docviewer.pot	2015-02-03 19:12:45 +0000
+++ po/com.ubuntu.docviewer.pot	2015-02-04 14:35:20 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: \n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2015-02-03 20:12+0100\n"
+"POT-Creation-Date: 2015-02-04 12:30+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -82,7 +82,7 @@
 msgid "Close"
 msgstr ""
 
-#: ../src/app/qml/PdfView.qml:30 ../src/app/qml/PdfView.qml:99
+#: ../src/app/qml/PdfView.qml:31
 #, qt-format
 msgid "Page %1 of %2"
 msgstr ""
@@ -127,7 +127,7 @@
 msgstr ""
 
 #: ../src/app/qml/WelcomePage.qml:23
-#: /home/stefano/Progetti/doc-viewer/build-10-prepare-poppler-plugin-Desktop-Default/po/com.ubuntu.docviewer.desktop.in.in.h:1
+#: /home/stefano/Progetti/doc-viewer/build-20-enable-zoom-Desktop-Default/po/com.ubuntu.docviewer.desktop.in.in.h:1
 msgid "Document Viewer"
 msgstr ""
 
@@ -143,6 +143,6 @@
 msgid "Open a file..."
 msgstr ""
 
-#: /home/stefano/Progetti/doc-viewer/build-10-prepare-poppler-plugin-Desktop-Default/po/com.ubuntu.docviewer.desktop.in.in.h:2
+#: /home/stefano/Progetti/doc-viewer/build-20-enable-zoom-Desktop-Default/po/com.ubuntu.docviewer.desktop.in.in.h:2
 msgid "documents;viewer;pdf;reader;"
 msgstr ""

=== modified file 'src/app/main.cpp'
--- src/app/main.cpp	2015-01-16 16:46:46 +0000
+++ src/app/main.cpp	2015-02-04 14:35:20 +0000
@@ -22,6 +22,9 @@
  *          Stefano Verzegnassi <[e-mail]>
  */
 
+// Uncomment if you need to use QML analyzer
+// #define QT_QML_DEBUG
+
 #include <QtGui/QGuiApplication>
 #include <QtQuick/QQuickView>
 #include <QtQml/QtQml>
@@ -36,6 +39,10 @@
     QQuickView view;
     view.setResizeMode(QQuickView::SizeRootObjectToView);
 
+    view.setPersistentOpenGLContext(false);
+    view.setPersistentSceneGraph(false);
+    view.engine()->rootContext()->setContextProperty("QQuickView", &view);
+
     // Set up import paths
     QStringList importPathList = view.engine()->importPathList();
     // Prepend the location of the plugin in the build dir,

=== modified file 'src/app/qml/PdfView.qml'
--- src/app/qml/PdfView.qml	2015-01-30 17:44:25 +0000
+++ src/app/qml/PdfView.qml	2015-02-04 14:35:20 +0000
@@ -24,93 +24,73 @@
     id: pdfPage
     title: Utils.getNameOfFile(file.path);
 
-    // Disable header auto-hide
+    // Disable header auto-hide.
+    // TODO: Show/hide header if a user taps the page
     flickable: null
 
-    property string currentPage: i18n.tr("Page %1 of %2").arg(pdfView.currentIndex + 1).arg(pdfView.count)
+    property string currentPage: i18n.tr("Page %1 of %2").arg(pdfView.currentPageIndex + 1).arg(pdfView.count)
 
-    // TODO: Restore zooming
-    ListView {
+    PDF.VerticalView {
         id: pdfView
         objectName:"pdfView"
 
-        anchors {
-            fill: parent
-            leftMargin: units.gu(1)
-            rightMargin: units.gu(1)
-        }
+        anchors.fill: parent
         spacing: units.gu(2)
 
         clip: true
-        focus: false
         boundsBehavior: Flickable.StopAtBounds
 
-        cacheBuffer: height
-
-        highlightFollowsCurrentItem: false
-        keyNavigationWraps: false
-
-        header: Item { width: parent.width; height: units.gu(2) }
-        footer: Item { width: parent.width; height: units.gu(2) }
-
-        model: PDF.Document {
-            id: poppler
-
-            /* FIXME: Don't set 'path' property directly, but set it through onCompleted signal.
-               By doing otherwise, PDF pages are loaded two times, but only
-               the first delegates are working. Asking to the image provider
-               to get the second ones, makes the app instable.
-               (e.g. We have a PDF document with 10 pages. The plugin loads
-               them twice - 2x10 = 20 pages - but only the first 10 are shown.
-               While trying to get the 11th, the app crashes). */
-            Component.onCompleted: path = file.path
-
-            onPagesLoaded: {
-                activity.running = false;
-
-                pdfView.currentIndex = 0
-
-                var title = getDocumentInfo("Title")
-                if (title !== "")
-                    pdfPage.title = title
-            }
-        }
-
-        delegate: PdfViewDelegate {}
-
-        onWidthChanged: {
-            /* On resizing window, pages size changes but contentY is still the same.
-               For that reason, it shows the wrong page (which is settled at the same contentY).
-               We need to force flickable to show the current page. */
-            //pdfView.positionViewAtIndex(currentIndex, ListView.Contain)
-        }
-
-        onContentYChanged: {
-            // FIXME: On wheeling up, ListView automatically center currentItem to the view.
-            //        This causes some strange "jump" of ~200px in contentY
-            var i = pdfView.indexAt(pdfView.width * 0.5, contentY + (pdfView.height * 0.5))
-
-            if (i < 0) {
-                // returned index could be -1 when the delegate spacing is shown at the center of the view (e.g. while scrolling pages)
-                i = pdfView.indexAt(pdfView.width * 0.5, contentY + (pdfView.height * 0.5) + units.gu(4))
-            }
-
-            if (i !== -1) {
-                currentPage = i18n.tr("Page %1 of %2").arg(i + 1).arg(pdfView.count)
-
-                if (!pdfView.flickingVertically) {
-                    pdfView.currentIndex = i
-                }
-            }
-        }
-    }
-
-    ActivityIndicator {
-        id: activity
-        anchors.centerIn: parent
-
-        running: true
-    }
+        cacheBuffer: height * poppler.providersNumber * _zoomHelper.scale * 0.5
+
+        flickDeceleration: 1500 * units.gridUnit / 8
+        maximumFlickVelocity: 2500 * units.gridUnit / 8
+
+        model: poppler
+        delegate: PdfViewDelegate {
+            onWidthChanged: QQuickView.releaseResources()
+            Component.onDestruction: QQuickView.releaseResources()
+        }
+
+        contentWidth: parent.width * _zoomHelper.scale
+        PinchArea {
+            id: pinchy
+            anchors.fill: parent
+
+            pinch {
+                target: _zoomHelper
+                minimumScale: 1.0
+                maximumScale: 2.5
+            }
+
+            onPinchStarted: pdfView.interactive = false;
+
+            // FIXME: On zooming, keep the same content position.
+            // onPinchUpdated: {}
+
+            onPinchFinished: {
+                pdfView.interactive = true;
+                pdfView.returnToBounds();
+            }
+        }
+
+        Item { id: _zoomHelper }
+    }
+
+    PDF.Document {
+        id: poppler
+
+        property bool isLoading: true
+
+        Component.onCompleted: path = file.path
+        onPagesLoaded: {
+            isLoading = false;
+
+            var title = getDocumentInfo("Title")
+            if (title !== "")
+                pdfPage.title = title
+        }
+    }
+
 
     // *** HEADER ***
     state: "default"

=== modified file 'src/app/qml/PdfViewDelegate.qml'
--- src/app/qml/PdfViewDelegate.qml	2015-01-31 10:31:44 +0000
+++ src/app/qml/PdfViewDelegate.qml	2015-02-04 14:35:20 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-2015 Canonical, Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -13,56 +13,83 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-
 import QtQuick 2.3
 import Ubuntu.Components 1.1
-import QtGraphicalEffects 1.0
 
 Rectangle {
     id: pdfPage
+
+    property int index: model.index
+    property bool _previewFetched: false
+
+    property alias status: pageImg.status
+
     width: parent.width
-
     height: width * (model.height / model.width)
-
-    border {
-        width: 1
-        color: "#808080"
+    color: "#E6E6E6"
+
+    // Preview page rendering. Used as placeholder while zooming the page.
+    // We generate the low resolution preview from the texture of the PDF page,
+    // so that we can keep page rendering as fast as possible.
+    ShaderEffectSource {
+        id: previewImg
+        anchors.fill: parent
+
+        // We cannot change its opacity or visibility, otherwise the texture will be refreshed,
+        // even if live is false.
+        live: false
+        textureSize: Qt.size(256, 256 * (model.height / model.width))
     }
 
     Image {
-        id: imagePage
-        anchors {
-            fill: parent
-            margins: 1
-        }
-        asynchronous: true
-        sourceSize.width: parent.width - 2
-        fillMode: Image.PreserveAspectCrop
-
-        Component.onCompleted: source = "image://poppler/page/" + model.index
-    }
-
-    Rectangle {
-        anchors.fill: parent
-        color: "white"
-        visible: imagePage.status === Image.Loading
-
-        ActivityIndicator {
-            anchors.centerIn: parent
-            running: parent.visible
-        }
-    }
-
-    DropShadow {
-        anchors.fill: parent
-        cached: true;
-        horizontalOffset: 0;
-        verticalOffset: 2;
-        radius: 8.0;
-        samples: 16;
-        color: "#80000000";
-        smooth: true;
-        source: parent;
-        z: -10
+        id: pageImg
+        anchors.fill: parent
+
+        source: "image://poppler" + (index % poppler.providersNumber) + "/page/" + index;
+        sourceSize.width: pdfPage.width
+
+        onStatusChanged: {
+            // This is supposed to run the first time PdfViewDelegate gets the page rendering.
+            if (!_previewFetched) {
+                if (status == Image.Ready) {
+                    previewImg.sourceItem = pageImg
+                    // Re-assign sourceItem property, so the texture is not updated when Image status changes.
+                    previewImg.sourceItem = pdfPage
+                }
+            }
+        }
+
+        // Request a new page rendering. The order, which pages are requested with, depends on the distance from the currentPage
+        Timer {
+            id: _zoomTimer
+            interval: {
+                var diff = Math.abs(pdfView.currentPageIndex - model.index)
+                var prov = poppler.providersNumber * 0.5
+
+                if (diff < prov)
+                    return 0
+                else
+                    return (diff - prov) * 10
+            }
+
+            onTriggered: {
+                pageImg.sourceSize.width = pdfPage.width;
+            }
+        }
+    }
+
+    // Page rendering depends on the width of PdfViewDelegate.
+    // Because of this, we have multiple callings to ImageProvider while zooming.
+    // Just avoid it.
+    Connections {
+        target: pinchy
+
+        onPinchStarted: _zoomTimer.stop();
+        onPinchUpdated: {
+            // This ensures that page image is not reloaded when the maximumScale or minimumScale has already been reached.
+            if ( !(_zoomHelper.scale >= 2.5 && pinch.scale > 1.0) && !(_zoomHelper.scale <= 1.0 && pinch.scale < 1.0) )
+                pageImg.sourceSize.width = 0;
+        }
+        onPinchFinished: _zoomTimer.restart();
     }
 }

=== modified file 'src/app/qml/PdfViewGotoDialog.qml'
--- src/app/qml/PdfViewGotoDialog.qml	2015-01-29 19:14:08 +0000
+++ src/app/qml/PdfViewGotoDialog.qml	2015-02-04 14:35:20 +0000
@@ -54,7 +54,7 @@
     }
 
     function goToPage() {
-        pdfView.positionViewAtIndex((goToPageTextField.text - 1), ListView.Beginning)
+        pdfView.positionAtIndex((goToPageTextField.text - 1))
         PopupUtils.close(goToPageDialog)
     }
 }

=== modified file 'src/plugin/poppler-qml-plugin/CMakeLists.txt'
--- src/plugin/poppler-qml-plugin/CMakeLists.txt	2015-02-03 18:50:36 +0000
+++ src/plugin/poppler-qml-plugin/CMakeLists.txt	2015-02-04 14:35:20 +0000
@@ -1,5 +1,10 @@
 set(PLUGIN_DIR com/ubuntu/popplerqmlplugin)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${CMAKE_CURRENT_BINARY_DIR}
+	${Qt5Quick_PRIVATE_INCLUDE_DIRS}
+	${Qt5Qml_PRIVATE_INCLUDE_DIRS}
+)
 
 #add the sources to compile
 set(popplerqmlplugin_SRCS
@@ -8,6 +13,7 @@
     pdfimageprovider.cpp
     pdfthread.cpp
     pdfitem.cpp
+    verticalview.cpp
 )
 
 add_library(popplerqmlplugin MODULE

=== modified file 'src/plugin/poppler-qml-plugin/pdfdocument.cpp'
--- src/plugin/poppler-qml-plugin/pdfdocument.cpp	2015-01-30 18:42:00 +0000
+++ src/plugin/poppler-qml-plugin/pdfdocument.cpp	2015-02-04 14:35:20 +0000
@@ -25,10 +25,12 @@
 #include <QDebug>
 #include <QQmlEngine>
 #include <QQmlContext>
+#include <QThread>
 
 PdfDocument::PdfDocument(QAbstractListModel *parent):
     QAbstractListModel(parent)
   , m_path("")
+  , m_providersNumber(-1)
 {
     qRegisterMetaType<PdfPagesList>("PdfPagesList");
 }
@@ -163,12 +165,24 @@
 
 void PdfDocument::loadProvider()
 {
-    qDebug() << "Loading image provider...";
+    // WORKAROUND: QQuickImageProvider should create multiple threads to load more images at the same time.
+    // [QTBUG-37998] QQuickImageProvider can block its separate thread with ForceAsynchronousImageLoading
+    // Link: https://bugreports.qt.io/browse/QTBUG-37988
+    int newProvidersNumber = QThread::idealThreadCount();
+    if (newProvidersNumber != m_providersNumber) {
+        m_providersNumber = newProvidersNumber;
+        Q_EMIT providersNumberChanged();
+    }
+
+    qDebug() << "Ideal number of image providers is:" << m_providersNumber;
+
+    qDebug() << "Loading image provider(s)...";
     QQmlEngine *engine = QQmlEngine::contextForObject(this)->engine();
 
-    engine->addImageProvider(QLatin1String("poppler"), new PdfImageProvider(m_document));
+    for (int i=0; i<m_providersNumber; i++)
+        engine->addImageProvider(QLatin1String("poppler" + QByteArray::number(i)), new PdfImageProvider(m_document));
 
-    qDebug() << "Image provider loaded successfully !";
+    qDebug() << "Image provider(s) loaded successfully !";
 }
 
 PdfDocument::~PdfDocument()

=== modified file 'src/plugin/poppler-qml-plugin/pdfdocument.h'
--- src/plugin/poppler-qml-plugin/pdfdocument.h	2015-01-30 18:10:21 +0000
+++ src/plugin/poppler-qml-plugin/pdfdocument.h	2015-02-04 14:35:20 +0000
@@ -31,6 +31,7 @@
     Q_OBJECT
     Q_DISABLE_COPY(PdfDocument)
     Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
+    Q_PROPERTY(int providersNumber READ providersNumber NOTIFY providersNumberChanged)
 
 public:
     enum Roles {
@@ -44,6 +45,8 @@
     QString path() const { return m_path; }
     void setPath(QString &pathName);
 
+    int providersNumber() const { return m_providersNumber; }
+
     QHash<int, QByteArray> roleNames() const;
 
     int rowCount(const QModelIndex & parent = QModelIndex()) const;
@@ -56,12 +59,14 @@
     void pathChanged();
     void error(const QString& errorMessage);
     void pagesLoaded();
+    void providersNumberChanged();
 
 private slots:
     void _q_populate(PdfPagesList pagesList);
 
 private:
     QString m_path;
+    int m_providersNumber;
 
     bool loadDocument(QString &pathNAme);
     void loadProvider();

=== modified file 'src/plugin/poppler-qml-plugin/plugin.cpp'
--- src/plugin/poppler-qml-plugin/plugin.cpp	2015-01-30 17:44:25 +0000
+++ src/plugin/poppler-qml-plugin/plugin.cpp	2015-02-04 14:35:20 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013 Canonical, Ltd.
+ * Copyright (C) 2013-2015 Canonical, Ltd.
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -20,6 +20,7 @@
 
 #include "plugin.h"
 #include "pdfdocument.h"
+#include "verticalview.h"
 
 void PopplerPlugin::registerTypes(const char *uri)
 {
@@ -27,6 +28,7 @@
     
     //@uri com.ubuntu.popplerqmlplugin
     qmlRegisterType<PdfDocument>(uri, 1, 0, "Document");
+    qmlRegisterType<VerticalView>(uri, 1, 0, "VerticalView");
 }
 
 void PopplerPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== added file 'src/plugin/poppler-qml-plugin/verticalview.cpp'
--- src/plugin/poppler-qml-plugin/verticalview.cpp	1970-01-01 00:00:00 +0000
+++ src/plugin/poppler-qml-plugin/verticalview.cpp	2015-02-04 14:35:20 +0000
@@ -0,0 +1,884 @@
+/*
+ * Copyright (C) 2013-2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * Some documentation on how this thing works:
+ *
+ * A flickable has two very important concepts that define the top and
+ * height of the flickable area.
+ * The top is returned in minYExtent()
+ * The height is set using setContentHeight()
+ * By changing those two values we can make the list grow up or down
+ * as needed. e.g. if we are in the middle of the list
+ * and something that is above the viewport grows, since we do not
+ * want to change the viewport because of that we just adjust the
+ * minYExtent so that the list grows up.
+ *
+ * The implementation on the list relies on the delegateModel doing
+ * most of the instantiation work. You call createItem() when you
+ * need to create an item asking for it async or not. If returns null
+ * it means the item will be created async and the model will call the
+ * itemCreated slot with the item.
+ *
+ * updatePolish is the central point of dispatch for the work of the
+ * class. It is called by the scene graph just before drawing the class.
+ * In it we:
+ *  * Make sure all items are positioned correctly
+ *  * Add/Remove items if needed
+ *  * Update the content height if it was dirty
+ *
+ * m_visibleItems contains all the items we have created at the moment.
+ * Actually not all of them are visible since it includes the ones
+ * in the cache area we create asynchronously to help performance.
+ * The first item in m_visibleItems has the m_firstVisibleIndex in
+ * the model. If you actually want to know what is the first
+ * item in the viewport you have to find the first non culled element
+ * in m_visibleItems
+ *
+ * The first item of m_visibleItems is the one that defines the
+ * positions of all the rest of items (see updatePolish()) and
+ * this is why sometimes we move it even if it's not the item
+ * that has triggered the function (i.e. in itemGeometryChanged())
+ *
+ * m_visibleItems is a list of ListItem. Each ListItem
+ * will contain a item and potentially a sectionItem. The sectionItem
+ * is only there when the list is using sectionDelegate+sectionProperty
+ * and this is the first item of the section. Each ListItem is vertically
+ * layouted with the sectionItem first and then the item.
+ *
+ * Note that minYExtent and height are not always totally accurate, since
+ * we don't have the items created we can't guess their heights
+ * so we can only guarantee the values are correct when the first/last
+ * items of the list are visible, otherwise we just live with good enough
+ * values that make the list scrollable
+ *
+ * There are a few things that are not really implemented or tested properly
+ * which we don't use at the moment like changing the model, etc.
+ * The known missing features are marked with TODOs along the code.
+ */
+
+#include "verticalview.h"
+
+#include <QCoreApplication>
+#include <QDebug>
+#include <qqmlinfo.h>
+#include <qqmlengine.h>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-pedantic"
+#include <private/qqmldelegatemodel_p.h>
+#include <private/qqmlglobal_p.h>
+#include <private/qquickitem_p.h>
+#include <private/qquickanimation_p.h>
+#pragma GCC diagnostic pop
+
+qreal VerticalView::ListItem::height() const
+{
+    return m_item->height();
+}
+
+qreal VerticalView::ListItem::y() const
+{
+    return m_item->y();
+}
+
+void VerticalView::ListItem::setY(qreal newY)
+{
+    m_item->setY(newY);
+}
+
+bool VerticalView::ListItem::culled() const
+{
+    return QQuickItemPrivate::get(m_item)->culled;
+}
+
+void VerticalView::ListItem::setCulled(bool culled)
+{
+    QQuickItemPrivate::get(m_item)->setCulled(culled);
+}
+
+VerticalView::VerticalView()
+ : m_delegateModel(nullptr)
+ , m_asyncRequestedIndex(-1)
+ , m_delegateValidated(false)
+ , m_firstVisibleIndex(-1)
+ , m_currentPageIndex(-1)
+ , m_minYExtent(0)
+ , m_contentHeightDirty(false)
+ , m_previousContentY(0)
+ , m_inLayout(false)
+ , m_cacheBuffer(0)
+ , m_spacing(0)
+{
+    connect(this, SIGNAL(heightChanged()), this, SLOT(_q_heightChanged()));
+    connect(this, SIGNAL(contentYChanged()), this, SLOT(_q_updateCurrentPageIndex()));
+
+    setFlickableDirection(QQuickFlickable::HorizontalAndVerticalFlick);
+}
+
+VerticalView::~VerticalView()
+{
+}
+
+QAbstractItemModel *VerticalView::model() const
+{
+    return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() : nullptr;
+}
+
+void VerticalView::setModel(QAbstractItemModel *model)
+{
+    if (model != this->model()) {
+        if (!m_delegateModel) {
+            createDelegateModel();
+        } else {
+            disconnect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)), this, SLOT(_q_modelUpdated(QQmlChangeSet,bool)));
+        }
+        m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));
+        connect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)), this, SLOT(_q_modelUpdated(QQmlChangeSet,bool)));
+        Q_EMIT modelChanged();
+        polish();
+        // TODO?
+//         Q_EMIT contentHeightChanged();
+//         Q_EMIT contentYChanged();
+    }
+}
+
+QQmlComponent *VerticalView::delegate() const
+{
+    return m_delegateModel ? m_delegateModel->delegate() : nullptr;
+}
+
+void VerticalView::setDelegate(QQmlComponent *delegate)
+{
+    if (delegate != this->delegate()) {
+        if (!m_delegateModel) {
+            createDelegateModel();
+        }
+
+        // Cleanup the existing items
+        Q_FOREACH(ListItem *item, m_visibleItems)
+            releaseItem(item);
+        m_visibleItems.clear();
+        m_firstVisibleIndex = -1;
+        adjustMinYExtent();
+        setContentY(0);
+
+        m_delegateModel->setDelegate(delegate);
+
+        Q_EMIT delegateChanged();
+        m_delegateValidated = false;
+        m_contentHeightDirty = true;
+        polish();
+    }
+}
+
+int VerticalView::cacheBuffer() const
+{
+    return m_cacheBuffer;
+}
+
+void VerticalView::setCacheBuffer(int cacheBuffer)
+{
+    if (cacheBuffer < 0) {
+        qmlInfo(this) << "Cannot set a negative cache buffer";
+        return;
+    }
+
+    if (cacheBuffer != m_cacheBuffer) {
+        m_cacheBuffer = cacheBuffer;
+        Q_EMIT cacheBufferChanged();
+        polish();
+    }
+}
+
+qreal VerticalView::spacing() const
+{
+    return m_spacing;
+}
+
+void VerticalView::setSpacing(qreal spacing)
+{
+    if (spacing < 0) {
+        qmlInfo(this) << "Cannot set a negative spacing";
+        return;
+    }
+
+    if (spacing != m_spacing) {
+        m_spacing = spacing;
+        Q_EMIT spacingChanged();
+        polish();
+    }
+}
+
+int VerticalView::count() const
+{
+    if (m_delegateModel)
+        return m_delegateModel->count();
+    else
+        return 0;
+}
+
+int VerticalView::currentPageIndex() const
+{
+    return m_currentPageIndex;
+}
+
+QQuickItem *VerticalView::currentPageItem() const
+{
+    return itemAt(m_currentPageIndex);
+}
+
+void VerticalView::_q_updateCurrentPageIndex()
+{
+    if (!m_visibleItems.isEmpty()) {
+        qreal pos = this->contentY() + (this->height() * 0.5);
+
+        int oldCurrentPageIndex = m_currentPageIndex;
+        int i = 0;
+
+        Q_FOREACH(ListItem * item, m_visibleItems) {
+            if (item->y() < pos && item->y() + item->height() > pos)
+                break;
+
+            i++;
+        }
+
+        // If spacing is set, there may be no page on posY position,
+        // and the Q_FOREACH loop keep on running until the end.
+        if (i != m_visibleItems.length())
+            m_currentPageIndex = m_firstVisibleIndex + i;
+
+        if (m_currentPageIndex != oldCurrentPageIndex) {
+            Q_EMIT currentPageIndexChanged();
+            Q_EMIT currentPageItemChanged();
+        }
+
+    }
+}
+
+void VerticalView::positionAtBeginning()
+{
+    if (m_delegateModel->count() <= 0)
+        return;
+
+    if (m_firstVisibleIndex != 0) {
+        // TODO This could be optimized by trying to reuse the interesection
+        // of items that may end up intersecting between the existing
+        // m_visibleItems and the items we are creating in the next loop
+        Q_FOREACH(ListItem *item, m_visibleItems)
+            releaseItem(item);
+        m_visibleItems.clear();
+        m_firstVisibleIndex = -1;
+
+        // Create the item 0, it will be already correctly positioned at createItem()
+        ListItem *item = createItem(0, false);
+        // Create the subsequent items
+        int modelIndex = 1;
+        qreal pos = item->y() + item->height();
+        const qreal bufferTo = height() + m_cacheBuffer;
+        while (modelIndex < m_delegateModel->count() && pos <= bufferTo) {
+            if (!(item = createItem(modelIndex, false)))
+                break;
+            pos += item->height();
+            ++modelIndex;
+        }
+
+        m_previousContentY = m_visibleItems.first()->y();
+    }
+    setContentY(m_visibleItems.first()->y());
+}
+
+void VerticalView::positionAtIndex(int index)
+{
+    if (m_delegateModel->count() <= 0)
+        return;
+
+    if (index < m_firstVisibleIndex || index > m_firstVisibleIndex + m_visibleItems.length()) {
+        // TODO This could be optimized by trying to reuse the interesection
+        // of items that may end up intersecting between the existing
+        // m_visibleItems and the items we are creating in the next loop
+        Q_FOREACH(ListItem *item, m_visibleItems)
+            releaseItem(item);
+        m_visibleItems.clear();
+        m_firstVisibleIndex = -1;
+
+        // Create the item with the given index, it will be already correctly positioned at createItem()
+        // Other items are created when createdItem() signal is emitted.
+        createItem(index, false);
+
+        m_previousContentY = m_visibleItems.first()->y();
+    }
+
+    setContentY(itemAt(index)->y());
+}
+
+void VerticalView::positionAtEnd()
+{
+    if (m_delegateModel->count() <= 0)
+        return;
+
+    if (m_firstVisibleIndex != m_delegateModel->count() - 1) {
+        // TODO This could be optimized by trying to reuse the interesection
+        // of items that may end up intersecting between the existing
+        // m_visibleItems and the items we are creating in the next loop
+        Q_FOREACH(ListItem *item, m_visibleItems)
+            releaseItem(item);
+        m_visibleItems.clear();
+        m_firstVisibleIndex = -1;
+
+        // Create the item 0, it will be already correctly positioned at createItem()
+        ListItem *item = createItem(m_delegateModel->count() - 1, false);
+        // Create the prior items
+        int modelIndex = m_delegateModel->count() - 2;
+        qreal pos = item->y() + item->height();
+        const qreal bufferFrom = contentY() - m_cacheBuffer;
+        while (modelIndex > -1 && pos >= bufferFrom) {
+            if (!(item = createItem(modelIndex, false)))
+                break;
+            pos += item->height();
+            --modelIndex;
+        }
+
+        m_previousContentY = m_visibleItems.first()->y();
+    }
+    setContentY(m_visibleItems.first()->y());
+}
+
+static inline bool uFuzzyCompare(qreal r1, qreal r2)
+{
+    return qFuzzyCompare(r1, r2) || (qFuzzyIsNull(r1) && qFuzzyIsNull(r2));
+}
+
+QQuickItem *VerticalView::itemAt(int modelIndex) const
+{
+    ListItem *item = itemAtIndex(modelIndex);
+    if (item)
+        return item->m_item;
+    else
+        return nullptr;
+}
+
+qreal VerticalView::minYExtent() const
+{
+    return m_minYExtent;
+}
+
+void VerticalView::componentComplete()
+{
+    if (m_delegateModel)
+        m_delegateModel->componentComplete();
+
+    QQuickFlickable::componentComplete();
+
+    polish();
+}
+
+void VerticalView::viewportMoved(Qt::Orientations orient)
+{
+    // Check we are not being taken down and don't paint anything
+    // TODO Check if we still need this in 5.2
+    // For reproduction just inifnite loop testDash or testDashContent
+    if (!QQmlEngine::contextForObject(this)->parentContext())
+        return;
+
+    QQuickFlickable::viewportMoved(orient);
+    m_previousContentY = contentY();
+    layout();
+    polish();
+}
+
+void VerticalView::createDelegateModel()
+{
+    m_delegateModel = new QQmlDelegateModel(qmlContext(this), this);
+    connect(m_delegateModel, SIGNAL(createdItem(int,QObject*)), this, SLOT(_q_itemCreated(int,QObject*)));
+    connect(m_delegateModel, SIGNAL(countChanged()), this, SIGNAL(countChanged()));
+    if (isComponentComplete())
+        m_delegateModel->componentComplete();
+    updateWatchedRoles();
+}
+
+void VerticalView::refill()
+{
+    if (m_inLayout) {
+        return;
+    }
+    if (!isComponentComplete()) {
+        return;
+    }
+
+    const qreal from = contentY();
+    const qreal to = from + height();
+    const qreal bufferFrom = from - m_cacheBuffer;
+    const qreal bufferTo = to + m_cacheBuffer;
+
+    bool added = addVisibleItems(from, to, false);
+    bool removed = removeNonVisibleItems(bufferFrom, bufferTo);
+    added |= addVisibleItems(bufferFrom, bufferTo, true);
+
+    if (added || removed) {
+        m_contentHeightDirty = true;
+    }
+}
+
+bool VerticalView::addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous)
+{
+    if (!delegate())
+        return false;
+
+    if (m_delegateModel->count() == 0)
+        return false;
+
+    ListItem *item;
+    int modelIndex = 0;
+    qreal pos = 0;
+    if (!m_visibleItems.isEmpty()) {
+        modelIndex = m_firstVisibleIndex + m_visibleItems.count();
+        item = m_visibleItems.last();
+        pos = item->y() + item->height() + m_spacing;
+    }
+    bool changed = false;
+
+    while (modelIndex < m_delegateModel->count() && pos <= fillTo) {
+        if (!(item = createItem(modelIndex, asynchronous)))
+            break;
+        pos += item->height() + m_spacing;
+        ++modelIndex;
+        changed = true;
+    }
+
+    modelIndex = 0;
+    pos = 0;
+    if (!m_visibleItems.isEmpty()) {
+        modelIndex = m_firstVisibleIndex - 1;
+        item = m_visibleItems.first();
+        pos = item->y();
+    }
+    while (modelIndex >= 0 && pos > fillFrom) {
+        if (!(item = createItem(modelIndex, asynchronous)))
+            break;
+        pos -= item->height() + m_spacing;
+        --modelIndex;
+        changed = true;
+    }
+
+    return changed;
+}
+
+void VerticalView::reallyReleaseItem(ListItem *listItem)
+{
+    QQuickItem *item = listItem->m_item;
+    QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);
+    if (flags & QQmlDelegateModel::Destroyed) {
+        item->setParentItem(nullptr);
+    }
+    delete listItem;
+}
+
+void VerticalView::releaseItem(ListItem *listItem)
+{
+    QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(listItem->m_item);
+    itemPrivate->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
+    m_itemsToRelease << listItem;
+}
+
+void VerticalView::updateWatchedRoles()
+{
+    if (m_delegateModel) {
+        QList<QByteArray> roles;
+        m_delegateModel->setWatchedRoles(roles);
+    }
+}
+
+bool VerticalView::removeNonVisibleItems(qreal bufferFrom, qreal bufferTo)
+{
+    // Do not remove items if we are overshooting up or down, since we'll come back
+    // to the "stable" position and delete/create items without any reason
+    if (contentY() < -m_minYExtent) {
+        return false;
+    } else if (contentY() + height() > contentHeight()) {
+        return false;
+    }
+    bool changed = false;
+
+    bool foundVisible = false;
+    int i = 0;
+    int removedItems = 0;
+    const auto oldFirstVisibleIndex = m_firstVisibleIndex;
+    while (i < m_visibleItems.count()) {
+        ListItem *item = m_visibleItems[i];
+        const qreal pos = item->y() + m_spacing;
+        if (pos + item->height() < bufferFrom || pos > bufferTo) {
+            releaseItem(item);
+            m_visibleItems.removeAt(i);
+            changed = true;
+            ++removedItems;
+        } else {
+            if (!foundVisible) {
+                foundVisible = true;
+                const int itemIndex = m_firstVisibleIndex + removedItems + i;
+                m_firstVisibleIndex = itemIndex;
+            }
+            ++i;
+        }
+    }
+    if (!foundVisible) {
+        m_firstVisibleIndex = -1;
+    }
+    if (m_firstVisibleIndex != oldFirstVisibleIndex) {
+        adjustMinYExtent();
+    }
+
+    return changed;
+}
+
+VerticalView::ListItem *VerticalView::createItem(int modelIndex, bool asynchronous)
+{
+    if (asynchronous && m_asyncRequestedIndex != -1)
+        return nullptr;
+
+    m_asyncRequestedIndex = -1;
+    QObject* object = m_delegateModel->object(modelIndex, asynchronous);
+    QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
+    if (!item) {
+        if (object) {
+            m_delegateModel->release(object);
+            if (!m_delegateValidated) {
+                m_delegateValidated = true;
+                QObject* delegateObj = delegate();
+                qmlInfo(delegateObj ? delegateObj : this) << "Delegate must be of Item type";
+            }
+        } else {
+            m_asyncRequestedIndex = modelIndex;
+        }
+        return 0;
+    } else {
+        ListItem *listItem = new ListItem;
+        listItem->m_item = item;
+        QQuickItemPrivate::get(item)->addItemChangeListener(this, QQuickItemPrivate::Geometry);
+        ListItem *prevItem = itemAtIndex(modelIndex - 1);
+        bool lostItem = false; // Is an item that we requested async but because of model changes
+                               // it is no longer attached to any of the existing items (has no prev nor next item)
+                               // nor is the first item
+        if (prevItem) {
+            listItem->setY(prevItem->y() + prevItem->height() + m_spacing);
+        } else {
+            ListItem *currItem = itemAtIndex(modelIndex);
+            if (currItem) {
+                // There's something already in m_visibleItems at out index, meaning this is an insert, so attach to its top
+                listItem->setY(currItem->y() - listItem->height() - m_spacing);
+            } else {
+                ListItem *nextItem = itemAtIndex(modelIndex + 1);
+                if (nextItem) {
+                    listItem->setY(nextItem->y() - listItem->height() - m_spacing);
+                } else if (modelIndex == 0) {
+                    listItem->setY(560);
+                } else if (!m_visibleItems.isEmpty()) {
+                    lostItem = true;
+                }
+            }
+        }
+        if (lostItem) {
+            listItem->setCulled(true);
+            releaseItem(listItem);
+            listItem = nullptr;
+        } else {
+            listItem->setCulled(listItem->y() + listItem->height() + m_spacing <= contentY() || listItem->y() >= contentY() + height());
+            if (m_visibleItems.isEmpty()) {
+                m_visibleItems << listItem;
+            } else {
+                m_visibleItems.insert(modelIndex - m_firstVisibleIndex, listItem);
+            }
+            if (m_firstVisibleIndex < 0 || modelIndex < m_firstVisibleIndex) {
+                m_firstVisibleIndex = modelIndex;
+                polish();
+            }
+            adjustMinYExtent();
+            m_contentHeightDirty = true;
+        }
+        return listItem;
+    }
+}
+
+void VerticalView::_q_itemCreated(int modelIndex, QObject *object)
+{
+    QQuickItem *item = qmlobject_cast<QQuickItem*>(object);
+    if (!item) {
+        qWarning() << "VerticalView::itemCreated got a non item for index" << modelIndex;
+        return;
+    }
+
+    // Check we are not being taken down and don't paint anything
+    // TODO Check if we still need this in 5.2
+    // For reproduction just inifnite loop testDash or testDashContent
+    if (!QQmlEngine::contextForObject(this)->parentContext())
+        return;
+
+    item->setParentItem(contentItem());
+    QQmlContext *context = QQmlEngine::contextForObject(item)->parentContext();
+    context->setContextProperty(QLatin1String("VerticalView"), this);
+    context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
+    if (modelIndex == m_asyncRequestedIndex) {
+        createItem(modelIndex, false);
+        refill();
+    }
+}
+
+void VerticalView::_q_heightChanged()
+{
+    polish();
+}
+
+void VerticalView::_q_modelUpdated(const QQmlChangeSet &changeSet, bool /*reset*/)
+{
+    // TODO Do something with reset
+    const auto oldFirstVisibleIndex = m_firstVisibleIndex;
+
+    Q_FOREACH(const QQmlChangeSet::Change &remove, changeSet.removes()) {
+        if (remove.index + remove.count > m_firstVisibleIndex && remove.index < m_firstVisibleIndex + m_visibleItems.count()) {
+            const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
+            // If all the items we are removing are either not created or culled
+            // we have to grow down to avoid viewport changing
+            bool growDown = true;
+            for (int i = 0; growDown && i < remove.count; ++i) {
+                const int modelIndex = remove.index + i;
+                ListItem *item = itemAtIndex(modelIndex);
+                if (item && !item->culled()) {
+                    growDown = false;
+                }
+            }
+            for (int i = remove.count - 1; i >= 0; --i) {
+                const int visibleIndex = remove.index + i - m_firstVisibleIndex;
+                if (visibleIndex >= 0 && visibleIndex < m_visibleItems.count()) {
+                    ListItem *item = m_visibleItems[visibleIndex];
+                    releaseItem(item);
+                    m_visibleItems.removeAt(visibleIndex);
+                }
+            }
+            if (growDown) {
+                adjustMinYExtent();
+            } else if (remove.index <= m_firstVisibleIndex) {
+                if (!m_visibleItems.isEmpty()) {
+                    // We removed the first item that is the one that positions the rest
+                    // position the new first item correctly
+                    m_visibleItems.first()->setY(oldFirstValidIndexPos);
+                } else {
+                    m_firstVisibleIndex = -1;
+                }
+            }
+        } else if (remove.index + remove.count <= m_firstVisibleIndex) {
+            m_firstVisibleIndex -= remove.count;
+        }
+        for (int i = remove.count - 1; i >= 0; --i) {
+            const int modelIndex = remove.index + i;
+            if (modelIndex == m_asyncRequestedIndex) {
+                m_asyncRequestedIndex = -1;
+            } else if (modelIndex < m_asyncRequestedIndex) {
+                m_asyncRequestedIndex--;
+            }
+        }
+    }
+
+    Q_FOREACH(const QQmlChangeSet::Change &insert, changeSet.inserts()) {
+        const bool insertingInValidIndexes = insert.index > m_firstVisibleIndex && insert.index < m_firstVisibleIndex + m_visibleItems.count();
+        const bool firstItemWithViewOnTop = insert.index == 0 && m_firstVisibleIndex == 0 && m_visibleItems.first()->y()  > contentY();
+        if (insertingInValidIndexes || firstItemWithViewOnTop)
+        {
+            // If the items we are adding won't be really visible
+            // we grow up instead of down to not change the viewport
+            bool growUp = false;
+            if (!firstItemWithViewOnTop) {
+                for (int i = 0; i < m_visibleItems.count(); ++i) {
+                    if (!m_visibleItems[i]->culled()) {
+                        if (insert.index <= m_firstVisibleIndex + i) {
+                            growUp = true;
+                        }
+                        break;
+                    }
+                }
+            }
+
+            const qreal oldFirstValidIndexPos = m_visibleItems.first()->y();
+            for (int i = insert.count - 1; i >= 0; --i) {
+                const int modelIndex = insert.index + i;
+                ListItem *item = createItem(modelIndex, false);
+                if (growUp) {
+                    ListItem *firstItem = m_visibleItems.first();
+                    firstItem->setY(firstItem->y() - item->height());
+                }
+            }
+            if (firstItemWithViewOnTop) {
+                ListItem *firstItem = m_visibleItems.first();
+                firstItem->setY(oldFirstValidIndexPos);
+            }
+            adjustMinYExtent();
+        } else if (insert.index <= m_firstVisibleIndex) {
+            m_firstVisibleIndex += insert.count;
+        }
+
+        for (int i = insert.count - 1; i >= 0; --i) {
+            const int modelIndex = insert.index + i;
+            if (modelIndex <= m_asyncRequestedIndex) {
+                m_asyncRequestedIndex++;
+            }
+        }
+    }
+
+    if (m_firstVisibleIndex != oldFirstVisibleIndex) {
+        adjustMinYExtent();
+    }
+
+    layout();
+    polish();
+    m_contentHeightDirty = true;
+}
+
+void VerticalView::itemGeometryChanged(QQuickItem * /*item*/, const QRectF &newGeometry, const QRectF &oldGeometry)
+{
+    const qreal heightDiff = newGeometry.height() - oldGeometry.height();
+    if (heightDiff != 0) {
+        if (oldGeometry.y() + oldGeometry.height() <= contentY() && !m_visibleItems.isEmpty()) {
+            ListItem *firstItem = m_visibleItems.first();
+            firstItem->setY(firstItem->y() - heightDiff);
+            adjustMinYExtent();
+            layout();
+        }
+        refill();
+        adjustMinYExtent();
+        polish();
+        m_contentHeightDirty = true;
+    }
+}
+
+void VerticalView::adjustMinYExtent()
+{
+    if (m_visibleItems.isEmpty()) {
+        m_minYExtent = 0;
+    } else {
+        qreal nonCreatedHeight = 0;
+        if (m_firstVisibleIndex != 0) {
+            // Calculate the average height of items to estimate the position of the list start
+            const int visibleItems = m_visibleItems.count();
+            qreal visibleItemsHeight = 0;
+            Q_FOREACH(ListItem *item, m_visibleItems) {
+                visibleItemsHeight += item->height() + m_spacing;
+            }
+            nonCreatedHeight = m_firstVisibleIndex * visibleItemsHeight / visibleItems;
+        }
+        m_minYExtent = nonCreatedHeight - m_visibleItems.first()->y();
+        if (m_minYExtent != 0 && qFuzzyIsNull(m_minYExtent)) {
+            m_minYExtent = 0;
+            m_visibleItems.first()->setY(nonCreatedHeight);
+        }
+    }
+}
+
+VerticalView::ListItem *VerticalView::itemAtIndex(int modelIndex) const
+{
+    const int visibleIndexedModelIndex = modelIndex - m_firstVisibleIndex;
+    if (visibleIndexedModelIndex >= 0 && visibleIndexedModelIndex < m_visibleItems.count())
+        return m_visibleItems[visibleIndexedModelIndex];
+
+    return nullptr;
+}
+
+void VerticalView::layout()
+{
+    if (m_inLayout)
+        return;
+
+    m_inLayout = true;
+    if (!m_visibleItems.isEmpty()) {
+        const qreal visibleFrom = contentY();
+        const qreal visibleTo = contentY() + height();
+
+        qreal pos = m_visibleItems.first()->y();
+
+//         qDebug() << "VerticalView::layout Updating positions and heights. contentY" << contentY() << "minYExtent" << minYExtent();
+        int firstReallyVisibleItem = -1;
+        int modelIndex = m_firstVisibleIndex;
+        Q_FOREACH(ListItem *item, m_visibleItems) {
+            const bool cull = pos + item->height() + m_spacing <= visibleFrom || pos >= visibleTo;
+            item->setCulled(cull);
+            item->setY(pos);
+            if (!cull && firstReallyVisibleItem == -1) {
+                firstReallyVisibleItem = modelIndex;
+            }
+            QQmlContext *context = QQmlEngine::contextForObject(item->m_item)->parentContext();
+            const qreal clipFrom = visibleFrom;
+            if (!cull && pos < clipFrom) {
+                context->setContextProperty(QLatin1String("heightToClip"), clipFrom - pos);
+            } else {
+                context->setContextProperty(QLatin1String("heightToClip"), QVariant::fromValue<int>(0));
+            }
+//             qDebug() << "VerticalView::layout" << item->m_item;
+            pos += item->height() + m_spacing;
+            ++modelIndex;
+        }
+    }
+    m_inLayout = false;
+}
+
+void VerticalView::updatePolish()
+{
+    // Check we are not being taken down and don't paint anything
+    // TODO Check if we still need this in 5.2
+    // For reproduction just inifnite loop testDash or testDashContent
+    if (!QQmlEngine::contextForObject(this)->parentContext())
+        return;
+
+    Q_FOREACH(ListItem *item, m_itemsToRelease)
+        reallyReleaseItem(item);
+    m_itemsToRelease.clear();
+
+    if (!model())
+        return;
+
+    layout();
+
+    refill();
+
+    if (m_contentHeightDirty) {
+        qreal contentHeight;
+        if (m_visibleItems.isEmpty()) {
+            contentHeight = 0;
+        } else {
+            const int modelCount = model()->rowCount();
+            const int visibleItems = m_visibleItems.count();
+            const int lastValidIndex = m_firstVisibleIndex + visibleItems - 1;
+            qreal nonCreatedHeight = 0;
+            if (lastValidIndex != modelCount - 1) {
+                const int visibleItems = m_visibleItems.count();
+                qreal visibleItemsHeight = 0;
+                Q_FOREACH(ListItem *item, m_visibleItems) {
+                    visibleItemsHeight += item->height() + m_spacing;
+                }
+                const int unknownSizes = modelCount - (m_firstVisibleIndex + visibleItems);
+                nonCreatedHeight = unknownSizes * visibleItemsHeight / visibleItems;
+            }
+            ListItem *item = m_visibleItems.last();
+            contentHeight = nonCreatedHeight + item->y() + item->height();
+            if (m_firstVisibleIndex != 0) {
+                // Make sure that if we are shrinking we tell the view we still fit
+                m_minYExtent = qMax(m_minYExtent, -(contentHeight - height()));
+            }
+        }
+
+        m_contentHeightDirty = false;
+        adjustMinYExtent();
+        setContentHeight(contentHeight);
+    }
+}
+
+#include "moc_verticalview.cpp"

=== added file 'src/plugin/poppler-qml-plugin/verticalview.h'
--- src/plugin/poppler-qml-plugin/verticalview.h	1970-01-01 00:00:00 +0000
+++ src/plugin/poppler-qml-plugin/verticalview.h	2015-02-04 14:35:20 +0000
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2013-2015 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef VERTICALVIEW_H
+#define VERTICALVIEW_H
+
+#include <private/qquickitemchangelistener_p.h>
+#include <private/qquickflickable_p.h>
+
+class QAbstractItemModel;
+class QQmlChangeSet;
+class QQmlDelegateModel;
+
+
+/**
+    Note for users of this class
+
+    VerticalView already loads delegates async when appropiate so if
+    your delegate uses a Loader you should not enable the asynchronous feature since
+    that will need to introduce sizing problems
+
+    With the double async it may happen what while we are scrolling down
+    we reach to a point where given the size of the just created delegate with loader not yet loaded (which will be very close to 0)
+    we are already "at the end" of the list, but then a few milliseconds later the loader finishes loading and we could
+    have kept scrolling. This is specially visible at the end of the list where you realize
+    that scrolling ended a bit before the end of the list but the speed of the flicking was good
+    to reach the end
+
+    By not having the second async we get a better sizing when the delegate is created and things work better
+*/
+
+class VerticalView : public QQuickFlickable, public QQuickItemChangeListener
+{
+    Q_OBJECT
+    Q_PROPERTY(QAbstractItemModel *model READ model WRITE setModel NOTIFY modelChanged)
+    Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY delegateChanged)
+    Q_PROPERTY(int cacheBuffer READ cacheBuffer WRITE setCacheBuffer NOTIFY cacheBufferChanged)
+    Q_PROPERTY(qreal spacing READ spacing WRITE setSpacing NOTIFY spacingChanged)
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+    Q_PROPERTY(int currentPageIndex READ currentPageIndex NOTIFY currentPageIndexChanged)
+    Q_PROPERTY(QQuickItem *currentPageItem READ currentPageItem NOTIFY currentPageItemChanged)
+
+public:
+    VerticalView();
+    ~VerticalView();
+
+    QAbstractItemModel *model() const;
+    void setModel(QAbstractItemModel *model);
+
+    QQmlComponent *delegate() const;
+    void setDelegate(QQmlComponent *delegate);
+
+    int cacheBuffer() const;
+    void setCacheBuffer(int cacheBuffer);
+
+    qreal spacing() const;
+    void setSpacing(qreal spacing);
+
+    int count() const;
+
+    int currentPageIndex() const;
+    QQuickItem *currentPageItem() const;
+
+    Q_INVOKABLE void positionAtBeginning();
+    Q_INVOKABLE void positionAtIndex(int index);
+    Q_INVOKABLE void positionAtEnd();
+
+    Q_INVOKABLE QQuickItem *itemAt(int modelIndex) const;
+
+Q_SIGNALS:
+    void modelChanged();
+    void delegateChanged();
+    void cacheBufferChanged();
+    void spacingChanged();
+    void countChanged();
+    void currentPageIndexChanged();
+    void currentPageItemChanged();
+
+protected:
+    void componentComplete() override;
+    void viewportMoved(Qt::Orientations orient) override;
+    qreal minYExtent() const override;
+    void itemGeometryChanged(QQuickItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) override;
+    void updatePolish() override;
+
+private Q_SLOTS:
+    void _q_itemCreated(int modelIndex, QObject *object);
+    void _q_heightChanged();
+    void _q_modelUpdated(const QQmlChangeSet &changeSet, bool reset);
+    void _q_updateCurrentPageIndex();
+
+private:
+    class ListItem
+    {
+        public:
+            qreal height() const;
+
+            qreal y() const;
+            void setY(qreal newY);
+
+            bool culled() const;
+            void setCulled(bool culled);
+
+            QQuickItem *m_item;
+    };
+
+    void createDelegateModel();
+
+    void layout();
+    void refill();
+    bool addVisibleItems(qreal fillFrom, qreal fillTo, bool asynchronous);
+    bool removeNonVisibleItems(qreal bufferFrom, qreal bufferTo);
+    ListItem *createItem(int modelIndex, bool asynchronous);
+
+    void adjustMinYExtent();
+    ListItem *itemAtIndex(int modelIndex) const; // Returns the item at modelIndex if has been created
+    void releaseItem(ListItem *item);
+    void reallyReleaseItem(ListItem *item);
+    void updateWatchedRoles();
+
+    QQmlDelegateModel *m_delegateModel;
+
+    // Index we are waiting because we requested it asynchronously
+    int m_asyncRequestedIndex;
+
+    // Used to only give a warning once if the delegate does not return objects
+    bool m_delegateValidated;
+
+    // Visible indexes, [0] is m_firstValidIndex, [0+1] is m_firstValidIndex +1, ...
+    QList<ListItem *> m_visibleItems;
+    int m_firstVisibleIndex;
+
+    int m_currentPageIndex;
+
+    qreal m_minYExtent;
+
+    // If any of the heights has changed
+    // or new items have been added/removed
+    bool m_contentHeightDirty;
+
+    qreal m_previousContentY;
+
+    bool m_inLayout;
+
+    int m_cacheBuffer;
+    qreal m_spacing;
+
+    // Qt 5.0 doesn't like releasing the items just after itemCreated
+    // so we delay the releasing until the next updatePolish
+    QList<ListItem *> m_itemsToRelease;
+};
+
+
+#endif // VERTICALVIEW_H

=== modified file 'tests/autopilot/ubuntu_docviewer_app/tests/test_docviewer.py'
--- tests/autopilot/ubuntu_docviewer_app/tests/test_docviewer.py	2014-12-14 20:50:23 +0000
+++ tests/autopilot/ubuntu_docviewer_app/tests/test_docviewer.py	2015-02-04 14:35:20 +0000
@@ -63,7 +63,7 @@
         self.launch_app()
 
         pdf = self.app.main_view.select_single(
-            "QQuickListView", objectName="pdfView")
+            "VerticalView", objectName="pdfView")
         self.assertThat(pdf.contentHeight,
                         Eventually(GreaterThan(0)))
 
@@ -78,5 +78,5 @@
 
         self.assertThat(
             self.app.main_view.select_single(
-                "QQuickListView", objectName="pdfView").currentIndex,
+                "VerticalView", objectName="pdfView").currentPageIndex,
             Eventually(Equals(int(page_no) - 1)))