Merge branch 'experimental/abstract_scaling' into develop

Author: AlienCowEatCake

src/ImageViewer/ImageViewer.pro

@@ -71,7 +71,12 @@ SOURCES += \
     src/Decoders/Impl/Internal/Animation/AnimationWidget.cpp \
     src/Decoders/Impl/Internal/Animation/FramesCompositor.cpp \
     src/Decoders/Impl/Internal/Animation/AbstractAnimationProvider.cpp \
-    src/Decoders/Impl/Internal/GraphicsItems/ImageResamplerWorker.cpp \
+    src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingManager.cpp \
+    src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingWorker.cpp \
+    src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingWorkerHandler.cpp \
+    src/Decoders/Impl/Internal/GraphicsItems/AutoUpdatedScalingWorkerHandler.cpp \
+    src/Decoders/Impl/Internal/GraphicsItems/GraphicsItemUtils.cpp \
+    src/Decoders/Impl/Internal/GraphicsItems/RasterizedImageGraphicsItem.cpp \
     src/Decoders/Impl/Internal/GraphicsItems/ResampledImageGraphicsItem.cpp \
     src/Decoders/Impl/Internal/Utils/ExifUtils.cpp \
     src/Decoders/Impl/Internal/Utils/CmsUtils.cpp \
@@ -95,7 +100,12 @@ HEADERS += \
     src/Decoders/Impl/Internal/Animation/FramesCompositor.h \
     src/Decoders/Impl/Internal/Animation/IAnimationProvider.h \
     src/Decoders/Impl/Internal/Animation/AbstractAnimationProvider.h \
-    src/Decoders/Impl/Internal/GraphicsItems/ImageResamplerWorker.h \
+    src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingManager.h \
+    src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingWorker.h \
+    src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingWorkerHandler.h \
+    src/Decoders/Impl/Internal/GraphicsItems/AutoUpdatedScalingWorkerHandler.h \
+    src/Decoders/Impl/Internal/GraphicsItems/GraphicsItemUtils.h \
+    src/Decoders/Impl/Internal/GraphicsItems/RasterizedImageGraphicsItem.h \
     src/Decoders/Impl/Internal/GraphicsItems/ResampledImageGraphicsItem.h \
     src/Decoders/Impl/Internal/Utils/ExifUtils.h \
     src/Decoders/Impl/Internal/Utils/CmsUtils.h \

src/ImageViewer/src/Decoders/Impl/DecoderLibWmf.cpp

@@ -27,14 +27,13 @@
 
 #include <QFileInfo>
 #include <QImage>
-#include <QPixmap>
 #include <QFile>
 #include <QByteArray>
-#include <QGraphicsItem>
 #include <QPainter>
 #include <QDebug>
 
 #include "../IDecoder.h"
+#include "Internal/GraphicsItems/RasterizedImageGraphicsItem.h"
 #include "Internal/DecoderAutoRegistrator.h"
 #include "Internal/Utils/ZLibUtils.h"
 
@@ -75,18 +74,17 @@ const char *wmfErrorToString(wmf_error_t error)
 
 // ====================================================================================================
 
-class WmfGraphicsItem : public QGraphicsItem
+class WmfPixmapProvider : public RasterizedImageGraphicsItem::IRasterizedImageProvider
 {
 public:
-    WmfGraphicsItem(const QString &filePath)
+    WmfPixmapProvider(const QString &filePath)
         : m_isValid(false)
         , m_API(NULL)
         , m_ddata(NULL)
         , m_width(0)
         , m_height(0)
         , m_minScaleFactor(1)
         , m_maxScaleFactor(1)
-        , m_cachedScaleFactor(0)
     {
         memset(&m_bbox, 0, sizeof(wmfD_Rect));
 
@@ -164,7 +162,7 @@ class WmfGraphicsItem : public QGraphicsItem
         m_maxScaleFactor = std::min(MAX_IMAGE_DIMENSION / m_width, MAX_IMAGE_DIMENSION / m_height);
     }
 
-    ~WmfGraphicsItem()
+    ~WmfPixmapProvider()
     {
         if(!isValid())
             return;
@@ -182,37 +180,7 @@ class WmfGraphicsItem : public QGraphicsItem
         return QRectF(0, 0, m_width, m_height);
     }
 
-    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = NULL)
-    {
-        Q_UNUSED(option);
-        Q_UNUSED(widget);
-        if(!isValid())
-            return;
-
-        const QRectF identityRect = QRectF(0, 0, 1, 1);
-        const QRectF deviceTransformedRect = painter->deviceTransform().mapRect(identityRect);
-        const qreal deviceScaleFactor = std::max(deviceTransformedRect.width(), deviceTransformedRect.height());
-        const qreal actualScaleFactor = std::min(std::max(m_minScaleFactor, deviceScaleFactor), m_maxScaleFactor);
-        if(std::abs(actualScaleFactor - m_cachedScaleFactor) / std::max(actualScaleFactor, m_cachedScaleFactor) > 1e-2)
-        {
-            const bool previousPixmapIsValid = !m_cachedPixmap.isNull();
-            m_cachedPixmap = QPixmap();
-            m_cachedPixmap = getPixmap(actualScaleFactor);
-            if(m_cachedPixmap.isNull() && previousPixmapIsValid)
-            {
-                m_maxScaleFactor = m_cachedScaleFactor;
-                m_cachedPixmap = getPixmap(m_cachedScaleFactor);
-            }
-            else
-            {
-                m_cachedScaleFactor = actualScaleFactor;
-            }
-        }
-        painter->drawPixmap(boundingRect(), m_cachedPixmap, QRectF(0, 0, m_width * m_cachedScaleFactor, m_height * m_cachedScaleFactor));
-    }
-
-protected:
-    QPixmap getPixmap(const qreal scaleFactor)
+    QImage image(const qreal scaleFactor)
     {
         m_ddata->type = wmf_gd_image;
         m_ddata->bbox.TL.x = m_bbox.TL.x;
@@ -226,14 +194,14 @@ class WmfGraphicsItem : public QGraphicsItem
         if(error != wmf_E_None)
         {
             qWarning() << "Couldn't decode WMF file into pixbuf:" << wmfErrorToString(error);
-            return QPixmap();
+            return QImage();
         }
 
         int *gdPixels = NULL;
         if(m_ddata->gd_image == NULL || (gdPixels = wmf_gd_image_pixels(m_ddata->gd_image)) == NULL)
         {
             qWarning() << "Couldn't decode WMF file - no output (huh?)" << wmfErrorToString(error);
-            return QPixmap();
+            return QImage();
         }
 
         QImage image(static_cast<int>(m_ddata->width), static_cast<int>(m_ddata->height), QImage::Format_ARGB32);
@@ -254,11 +222,21 @@ class WmfGraphicsItem : public QGraphicsItem
                 *(imagePtr++) = qRgba(r, g, b, a);
             }
         }
-        return QPixmap::fromImage(image);
+        return image;
+    }
+
+    qreal minScaleFactor() const
+    {
+        return m_minScaleFactor;
+    }
+
+    qreal maxScaleFactor() const
+    {
+        return m_maxScaleFactor;
     }
 
 private:
-    Q_DISABLE_COPY(WmfGraphicsItem)
+    Q_DISABLE_COPY(WmfPixmapProvider)
 
     bool m_isValid;
     QByteArray m_inBuffer;
@@ -269,9 +247,6 @@ class WmfGraphicsItem : public QGraphicsItem
     unsigned int m_height;
     qreal m_minScaleFactor;
     qreal m_maxScaleFactor;
-
-    QPixmap m_cachedPixmap;
-    qreal m_cachedScaleFactor;
 };
 
 // ====================================================================================================
@@ -302,13 +277,11 @@ class DecoderLibWmf : public IDecoder
         if(!fileInfo.exists() || !fileInfo.isReadable())
             return NULL;
 
-        WmfGraphicsItem *item = new WmfGraphicsItem(filePath);
-        if(!item->isValid())
-        {
-            delete item;
+        QSharedPointer<WmfPixmapProvider> provider(new WmfPixmapProvider(filePath));
+        if(!provider->isValid())
             return NULL;
-        }
-        return item;
+
+        return new RasterizedImageGraphicsItem(provider);
     }
 };
 

src/ImageViewer/src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingManager.cpp

@@ -0,0 +1,81 @@
+/*
+   Copyright (C) 2017 Peter S. Zhigalov <[email protected]>
+
+   This file is part of the `ImageViewer' program.
+
+   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, either version 3 of the License, or
+   (at your option) any later version.
+
+   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/>.
+*/
+
+#include "AbstractScalingManager.h"
+
+#include <QObject>
+#include <QThread>
+
+#include "AbstractScalingWorker.h"
+#include "AbstractScalingWorkerHandler.h"
+
+AbstractScalingManager::AbstractScalingManager(AbstractScalingWorker *worker, AbstractScalingWorkerHandler *handler, QThread *thread)
+    : m_scalingWorker(worker)
+    , m_scalingThread(thread)
+    , m_scalingWorkerHandler(handler)
+{
+    m_scalingWorker->moveToThread(m_scalingThread);
+    QObject::connect(m_scalingThread, SIGNAL(started()), m_scalingWorker, SLOT(process()));
+}
+
+AbstractScalingManager::~AbstractScalingManager()
+{
+    abortTask();
+    m_scalingWorkerHandler->setDestroyOnFinished();
+}
+
+void AbstractScalingManager::startTask(const qreal scaleFactor)
+{
+    if(m_scalingWorkerHandler->isRunning())
+        return;
+
+    abortTask();
+    m_scalingWorker->setScaleFactor(scaleFactor);
+    m_scalingThread->start();
+}
+
+void AbstractScalingManager::abortTask()
+{
+    m_scalingWorker->abort();
+}
+
+void AbstractScalingManager::beginScaledImageProcessing()
+{
+    m_scalingWorker->lockScaledImage();
+}
+
+void AbstractScalingManager::endScaledImageProcessing()
+{
+    m_scalingWorker->unlockScaledImage();
+}
+
+bool AbstractScalingManager::hasScaledData() const
+{
+    return m_scalingWorker->hasScaledData();
+}
+
+QImage AbstractScalingManager::getScaledImage() const
+{
+    return m_scalingWorker->getScaledImage();
+}
+
+qreal AbstractScalingManager::getScaledScaleFactor() const
+{
+    return m_scalingWorker->getScaledScaleFactor();
+}

src/ImageViewer/src/Decoders/Impl/Internal/GraphicsItems/AbstractScalingManager.h

@@ -0,0 +1,56 @@
+/*
+   Copyright (C) 2017 Peter S. Zhigalov <[email protected]>
+
+   This file is part of the `ImageViewer' program.
+
+   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, either version 3 of the License, or
+   (at your option) any later version.
+
+   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/>.
+*/
+
+#if !defined(ABSTRACT_SCALING_MANAGER_H_INCLUDED)
+#define ABSTRACT_SCALING_MANAGER_H_INCLUDED
+
+#include <QImage>
+
+#include "Utils/ScopedPointer.h"
+
+class QThread;
+class AbstractScalingWorker;
+class AbstractScalingWorkerHandler;
+
+class AbstractScalingManager
+{
+public:
+    AbstractScalingManager(AbstractScalingWorker *worker, AbstractScalingWorkerHandler *handler, QThread *thread);
+    ~AbstractScalingManager();
+
+    void startTask(const qreal scaleFactor);
+    void abortTask();
+
+    void beginScaledImageProcessing();
+    void endScaledImageProcessing();
+
+    bool hasScaledData() const;
+    QImage getScaledImage() const;
+    qreal getScaledScaleFactor() const;
+
+protected:
+    AbstractScalingWorker *m_scalingWorker;
+    QThread *m_scalingThread;
+    AbstractScalingWorkerHandler *m_scalingWorkerHandler;
+
+private:
+    Q_DISABLE_COPY(AbstractScalingManager)
+};
+
+#endif // ABSTRACT_SCALING_MANAGER_H_INCLUDED