Merge lp:~aacid/unity8/croppedImageMinimumSourceSizeProvider into lp:unity8

[Albert Astals Cid]

Image Provider for PreserveAspectCrop fillmode

Unmerged revisions

2537. By Albert Astals Cid on 2016-07-15

First attempt at an image provider that does what CroppedImageMinimumSourceSize does

Saves double loading of files in the "bad" case

=== modified file 'plugins/Dash/CMakeLists.txt'
--- plugins/Dash/CMakeLists.txt	2016-06-02 09:32:33 +0000
+++ plugins/Dash/CMakeLists.txt	2016-07-15 11:14:48 +0000
@@ -28,6 +28,7 @@
     verticaljournal.cpp
     horizontaljournal.cpp
     organicgrid.cpp
+    croppedimageminimumsizeimageprovider.cpp
     )
 
 add_library(Dash-qml MODULE

=== modified file 'plugins/Dash/CardCreator.js'
--- plugins/Dash/CardCreator.js	2016-06-17 01:18:49 +0000
+++ plugins/Dash/CardCreator.js	2016-07-15 11:14:48 +0000
@@ -104,10 +104,10 @@
                                     %6 \n\
                                     width: root.fixedArtShapeSize.width; \n\
                                     height: root.fixedArtShapeSize.height; \n\
-                                    CroppedImageMinimumSourceSize { \n\
+                                    Image { \n\
                                         id: artImage; \n\
                                         objectName: "artImage"; \n\
-                                        source: artShapeLoader.cardArt; \n\
+                                        source: "image://croppedImageMinimumSize/" + artShapeLoader.cardArt; \n\
                                         asynchronous: %5; \n\
                                         visible: %4; \n\
                                         width: %2; \n\
@@ -147,10 +147,10 @@
                                     %6 \n\
                                     width: image.status !== Image.Ready ? 0 : image.width; \n\
                                     height: image.status !== Image.Ready ? 0 : image.height; \n\
-                                    CroppedImageMinimumSourceSize { \n\
+                                    Image { \n\
                                         id: artImage; \n\
                                         objectName: "artImage"; \n\
-                                        source: artShapeLoader.cardArt; \n\
+                                        source: "image://croppedImageMinimumSize/" + artShapeLoader.cardArt; \n\
                                         asynchronous: %5; \n\
                                         visible: %4; \n\
                                         width: %2; \n\
@@ -285,11 +285,11 @@
 // %2 is used as visible of mascotImage
 // %3 is injected as code to mascotImage
 // %4 is used as fallback image
-var kMascotImageCode = 'CroppedImageMinimumSourceSize { \n\
+var kMascotImageCode = 'Image { \n\
                             id: mascotImage; \n\
                             objectName: "mascotImage"; \n\
                             anchors { %1 } \n\
-                            source: cardData && cardData["mascot"] || %4; \n\
+                            source: "image://croppedImageMinimumSize/" + (cardData && cardData["mascot"] || %4); \n\
                             width: units.gu(6); \n\
                             height: units.gu(5.625); \n\
                             horizontalAlignment: Image.AlignHCenter; \n\

=== added file 'plugins/Dash/croppedimageminimumsizeimageprovider.cpp'
--- plugins/Dash/croppedimageminimumsizeimageprovider.cpp	1970-01-01 00:00:00 +0000
+++ plugins/Dash/croppedimageminimumsizeimageprovider.cpp	2016-07-15 11:14:48 +0000
@@ -0,0 +1,294 @@
+/*
+ * Copyright (C) 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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 "croppedimageminimumsizeimageprovider.h"
+
+#include <QBuffer>
+#include <QDebug>
+#include <QDir>
+#include <QImageReader>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+
+#include <QtGui/private/qguiapplication_p.h>
+#include <qpa/qplatformintegration.h>
+
+class AsyncImageResponse : public QQuickImageResponse, public QRunnable
+{
+    public:
+        AsyncImageResponse(const QString &id, const QSize &requestedSize, QQmlEngine *engine)
+         : m_id(id), m_requestedSize(requestedSize), m_engine(engine)
+        {
+            setAutoDelete(false);
+        }
+
+        QQuickTextureFactory *textureFactory() const override
+        {
+            return QQuickTextureFactory::textureFactoryForImage(m_image);
+        }
+
+        void readImage(const QUrl &u, QIODevice *dev)
+        {
+            QImageReader imgio(dev);
+
+            if (m_requestedSize.width() > 0 && m_requestedSize.height() > 0) {
+                QSize s = imgio.size();
+                const qreal imageRatio = s.width() / qreal(s.height());
+                const qreal requestedRatio = m_requestedSize.width() / qreal(m_requestedSize.height());
+                qreal ratio;
+
+                if (requestedRatio > imageRatio) {
+                    ratio = m_requestedSize.width() / qreal(s.width());
+                } else {
+                    ratio = m_requestedSize.height() / qreal(s.height());
+                }
+
+                qDebug() << "Original size" << s;
+
+                s.setHeight(qRound(s.height() * ratio));
+                s.setWidth(qRound(s.width() * ratio));
+                imgio.setScaledSize(s);
+            }
+
+            if (!imgio.read(&m_image)) {
+                m_errorString = QString("Error decoding: %1: %2").arg(u.toString()).arg(imgio.errorString());
+            }
+
+            qDebug() << "ASYNCRESPONSE" << m_image;
+        }
+
+        void run() override
+        {
+            const QUrl u = QUrl::fromUserInput(m_id, QDir::currentPath());
+
+            qDebug() << "run" << u << u.isLocalFile();
+
+            if (u.isLocalFile()) {
+                QFile f(u.toLocalFile());
+                if (f.open(QIODevice::ReadOnly)) {
+                    readImage(u, &f);
+                } else {
+                    m_errorString = QString("Cannot open: %1").arg(u.toString());
+                }
+                emit finished();
+            } else if (u.scheme() == QLatin1String("image")) {
+                // Daisy chain :/
+                QQuickImageProvider *provider = dynamic_cast<QQuickImageProvider *>(m_engine->imageProvider(u.host()));
+
+                if (!provider) {
+                    m_errorString = QString("No image provider for: %1").arg(u.toString());
+                    emit finished();
+                    return;
+                }
+
+                const bool threadedPixmaps = QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ThreadedPixmaps);
+                const QQuickImageProvider::ImageType imageType = provider->imageType();
+                if (!threadedPixmaps && imageType == QQuickImageProvider::Pixmap) {
+                    m_errorString = QString("Can not daisy chain a pixmap provider, platform doesn't support threaded pixmaps: %1").arg(u.toString());
+                    emit finished();
+                    return;
+                }
+
+                const QString imageId = u.toString(QUrl::RemoveScheme | QUrl::RemoveAuthority).mid(1);
+
+                switch (imageType) {
+                    case QQuickImageProvider::Invalid:
+                    {
+                        m_errorString = QString("Invalid image provider: %1").arg(u.toString());
+                        break;
+                    }
+
+                    case QQuickImageProvider::Image:
+                    {
+                        QSize readSize;
+                        const QSize heightRequest = QSize(0, m_requestedSize.height());
+                        m_image = provider->requestImage(imageId, &readSize, heightRequest);
+
+                        if ((readSize.height() > 0) &&
+                            (m_requestedSize.height() > 0) &&
+                            ((readSize.width() / readSize.height()) < (m_requestedSize.width() / m_requestedSize.height())))
+                        {
+                            qDebug() << "DOUBLE REQUEST :/" << u;
+                            // Doing double request :/
+                            const QSize widthRequest = QSize(m_requestedSize.width(), 0);
+                            m_image = provider->requestImage(imageId, &readSize, widthRequest);
+                        }
+
+                        if (m_image.isNull()) {
+                            m_errorString = QString("Failed to get image from provider: %1").arg(u.toString());
+                        }
+                        emit finished();
+                        break;
+                    }
+
+                    case QQuickImageProvider::Pixmap:
+                    {
+                        QSize readSize;
+                        const QSize heightRequest = QSize(0, m_requestedSize.height());
+                        QPixmap pixmap = provider->requestPixmap(imageId, &readSize, heightRequest);
+
+                        if ((readSize.height() > 0) &&
+                            (m_requestedSize.height() > 0) &&
+                            ((readSize.width() / readSize.height()) < (m_requestedSize.width() / m_requestedSize.height())))
+                        {
+                            qDebug() << "DOUBLE REQUEST :/" << u;
+                            // Doing double request :/
+                            const QSize widthRequest = QSize(m_requestedSize.width(), 0);
+                            pixmap = provider->requestPixmap(imageId, &readSize, widthRequest);
+                        }
+
+                        m_image = pixmap.toImage();
+
+                        if (m_image.isNull()) {
+                            m_errorString = QString("Failed to get image from provider: %1").arg(u.toString());
+                        }
+
+                        emit finished();
+                        break;
+                    }
+
+                    case QQuickImageProvider::Texture:
+                    {
+                        QSize readSize;
+                        const QSize heightRequest = QSize(0, m_requestedSize.height());
+                        QQuickTextureFactory *t = provider->requestTexture(imageId, &readSize, heightRequest);
+
+                        if ((readSize.height() > 0) &&
+                            (m_requestedSize.height() > 0) &&
+                            ((readSize.width() / readSize.height()) < (m_requestedSize.width() / m_requestedSize.height())))
+                        {
+                            delete t;
+                            qDebug() << "DOUBLE REQUEST :/" << u;
+                            // Doing double request :/
+                            const QSize widthRequest = QSize(m_requestedSize.width(), 0);
+                            t = provider->requestTexture(imageId, &readSize, widthRequest);
+                        }
+
+                        if (!t) {
+                            m_errorString = QString("Failed to get texture from provider: %1").arg(u.toString());
+                        }
+
+                        // TODO Do something with t
+                        break;
+                    }
+
+                    case QQuickImageProvider::ImageResponse:
+                    {
+                        QQuickAsyncImageProvider *asyncProvider = static_cast<QQuickAsyncImageProvider*>(provider);
+                        const QSize heightRequest = QSize(0, m_requestedSize.height());
+                        QQuickImageResponse *response = asyncProvider->requestImageResponse(imageId, heightRequest);
+
+                        connect(response, &QQuickImageResponse::finished, this, &AsyncImageResponse::asyncResponseFinished);
+
+                        m_eventLoop = new QEventLoop();
+                        m_eventLoop->exec();
+                        delete m_eventLoop;
+                        m_eventLoop = 0;
+
+                        // TODO Do the double request magic
+                        // TODO Do something with response::textureFactory
+
+
+
+                        delete response;
+
+                        break;
+                    }
+                }
+
+            } else {
+                QNetworkAccessManager nam; // TODO only one of these?
+
+                int redirectCount = 0;
+
+                QUrl imageUrl = u;
+                bool needToGet = true;
+                while (needToGet && redirectCount < 16) {
+                    QNetworkRequest req(imageUrl);
+                    req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);
+                    QNetworkReply *reply = nam.get(req);
+                    connect(reply, &QNetworkReply::finished, this, &AsyncImageResponse::asyncResponseFinished);
+
+                    m_eventLoop = new QEventLoop();
+                    m_eventLoop->exec();
+                    delete m_eventLoop;
+                    m_eventLoop = 0;
+
+                    const QVariant redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
+                    if (redirect.isValid()) {
+                        imageUrl = reply->url().resolved(redirect.toUrl());
+                    } else {
+                        needToGet = false;
+
+                        if (reply->error()) {
+                            m_errorString = reply->errorString();
+                        } else {
+                            QByteArray all = reply->readAll();
+                            QBuffer buff(&all);
+                            buff.open(QIODevice::ReadOnly);
+                            readImage(reply->url(), &buff);
+                        }
+                    }
+                    delete reply;
+                }
+
+                emit finished();
+            }
+        }
+
+        QString errorString() const override
+        {
+            return m_errorString;
+        }
+
+        void cancel() override
+        {
+            // TODO for QNAM and ImageResponse
+        }
+
+    public slots:
+        void asyncResponseFinished()
+        {
+            m_eventLoop->exit();
+        }
+
+
+    private:
+        QString m_id;
+        QSize m_requestedSize;
+        QImage m_image;
+        QString m_errorString;
+        QQmlEngine *m_engine;
+        QEventLoop *m_eventLoop;
+};
+
+
+CroppedImageMinimumSizeImageProvider::CroppedImageMinimumSizeImageProvider(QQmlEngine *engine)
+    : QQuickAsyncImageProvider()
+    , m_engine(engine)
+{
+}
+
+CroppedImageMinimumSizeImageProvider::~CroppedImageMinimumSizeImageProvider()
+{
+}
+
+QQuickImageResponse *CroppedImageMinimumSizeImageProvider::requestImageResponse(const QString &id, const QSize &requestedSize)
+{
+    AsyncImageResponse *response = new AsyncImageResponse(id, requestedSize, m_engine);
+    m_pool.start(response);
+    return response;
+}

=== added file 'plugins/Dash/croppedimageminimumsizeimageprovider.h'
--- plugins/Dash/croppedimageminimumsizeimageprovider.h	1970-01-01 00:00:00 +0000
+++ plugins/Dash/croppedimageminimumsizeimageprovider.h	2016-07-15 11:14:48 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 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 version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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 CROPPEDIMAGEMINIMUMSIZEIMAGEPROVIDER_H
+#define CROPPEDIMAGEMINIMUMSIZEIMAGEPROVIDER_H
+
+#include <QQuickImageProvider>
+#include <QThreadPool>
+
+class CroppedImageMinimumSizeImageProvider : public QQuickAsyncImageProvider
+{
+public:
+    CroppedImageMinimumSizeImageProvider(QQmlEngine *engine);
+    virtual ~CroppedImageMinimumSizeImageProvider();
+
+    QQuickImageResponse *requestImageResponse(const QString &id, const QSize &requestedSize) override;
+
+private:
+    QThreadPool m_pool;
+    QQmlEngine *m_engine;
+};
+
+#endif // CURSORIMAGEPROVIDER_H

=== modified file 'plugins/Dash/plugin.cpp'
--- plugins/Dash/plugin.cpp	2016-02-19 08:44:42 +0000
+++ plugins/Dash/plugin.cpp	2016-07-15 11:14:48 +0000
@@ -17,6 +17,7 @@
 
 #include "plugin.h"
 
+#include "croppedimageminimumsizeimageprovider.h"
 #include "horizontaljournal.h"
 #include "listviewwithpageheader.h"
 #include "organicgrid.h"
@@ -67,4 +68,11 @@
     qmlRegisterSingletonType<AudioComparer>(uri, 0, 1, "AudioUrlComparer", audio_comparer_singleton_provider);
 }
 
+void DashPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
+{
+    QQmlExtensionPlugin::initializeEngine(engine, uri);
+
+    engine->addImageProvider(QStringLiteral("croppedImageMinimumSize"), new CroppedImageMinimumSizeImageProvider(engine));
+}
+
 #include "plugin.moc"

=== modified file 'plugins/Dash/plugin.h'
--- plugins/Dash/plugin.h	2015-04-30 09:31:51 +0000
+++ plugins/Dash/plugin.h	2016-07-15 11:14:48 +0000
@@ -28,6 +28,7 @@
 
 public:
     void registerTypes(const char *uri) override;
+    void initializeEngine(QQmlEngine *engine, const char *uri) override;
 };
 
 #endif