Issue #118: Move compiler and draw space controller

Pdf4QtLibWidgets/sources/pdfcompiler.h

@@ -0,0 +1,232 @@
+//    Copyright (C) 2019-2021 Jakub Melka
+//
+//    This file is part of PDF4QT.
+//
+//    PDF4QT is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU Lesser General Public License as published by
+//    the Free Software Foundation, either version 3 of the License, or
+//    with the written consent of the copyright owner, any later version.
+//
+//    PDF4QT is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU Lesser General Public License for more details.
+//
+//    You should have received a copy of the GNU Lesser General Public License
+//    along with PDF4QT.  If not, see <https://www.gnu.org/licenses/>.
+
+#ifndef PDFCOMPILER_H
+#define PDFCOMPILER_H
+
+#include "pdfwidgetsglobal.h"
+#include "pdfrenderer.h"
+#include "pdfpainter.h"
+#include "pdftextlayout.h"
+
+#include <QCache>
+#include <QFuture>
+#include <QFutureWatcher>
+#include <QWaitCondition>
+
+namespace pdf
+{
+class PDFDrawWidgetProxy;
+class PDFAsynchronousPageCompiler;
+
+class PDFAsynchronousPageCompilerWorkerThread : public QThread
+{
+    Q_OBJECT
+
+public:
+    explicit PDFAsynchronousPageCompilerWorkerThread(PDFAsynchronousPageCompiler* parent);
+
+signals:
+    void pageCompiled();
+
+protected:
+    virtual void run() override;
+
+private:
+    PDFAsynchronousPageCompiler* m_compiler;
+    QMutex* m_mutex;
+    QWaitCondition* m_waitCondition;
+};
+
+/// Asynchronous page compiler compiles pages asynchronously, and stores them in the
+/// cache. Cache size can be set. This object is designed to cooperate with
+/// draw widget proxy.
+class PDFAsynchronousPageCompiler : public QObject, public PDFOperationControl
+{
+    Q_OBJECT
+
+private:
+    using BaseClass = QObject;
+
+public:
+    explicit PDFAsynchronousPageCompiler(PDFDrawWidgetProxy* proxy);
+    virtual ~PDFAsynchronousPageCompiler();
+
+    /// Starts the engine. Call this function only if the engine
+    /// is stopped.
+    void start();
+
+    /// Stops the engine and all underlying asynchronous tasks. Also
+    /// clears the cache if needed. Call this function only if engine is active.
+    /// Cache is cleared only, if \p clearCache parameter is being set to true.
+    /// Set it to false, if "soft" document update occurs (this means change
+    /// to the document, which doesn't modify page content in precompiled
+    /// pages (graphic content / number of pages change).
+    /// \param clearCache Clear cache
+    void stop(bool clearCache);
+
+    /// Resets the engine - calls stop and then calls start.
+    void reset();
+
+    /// Sets cache limit in bytes
+    /// \param limit Cache limit [bytes]
+    void setCacheLimit(int limit);
+
+    enum class State
+    {
+        Inactive,
+        Active,
+        Stopping
+    };
+
+    /// Returns current state of compiler
+    State getState() const { return m_state; }
+
+    /// Return proxy
+    PDFDrawWidgetProxy* getProxy() const { return m_proxy; }
+
+    /// Tries to retrieve precompiled page from the cache. If page is not found,
+    /// then nullptr is returned (no exception is thrown). If \p compile is set to true,
+    /// and page is not found, and compiler is active, then new asynchronous compile
+    /// task is performed.
+    /// \param pageIndex Index of page
+    /// \param compile Compile the page, if it is not found in the cache
+    const PDFPrecompiledPage* getCompiledPage(PDFInteger pageIndex, bool compile);
+
+    /// Performs smart cache clear. Too old pages are removed from the cache,
+    /// but only if these pages are not in active pages. Use this function to
+    /// clear cache to avoid huge memory consumption.
+    /// \param milisecondsLimit Pages with access time above this limit will be erased
+    /// \param activePages Sorted vector of active pages, which should remain in cache
+    void smartClearCache(const int milisecondsLimit, const std::vector<PDFInteger>& activePages);
+
+    /// Is operation being cancelled?
+    virtual bool isOperationCancelled() const override;
+
+signals:
+    void pageImageChanged(bool all, const std::vector<pdf::PDFInteger>& pages);
+    void renderingError(pdf::PDFInteger pageIndex, const QList<pdf::PDFRenderError>& errors);
+
+private:
+    friend class PDFAsynchronousPageCompilerWorkerThread;
+
+    void onPageCompiled();
+
+    struct CompileTask
+    {
+        CompileTask() = default;
+        CompileTask(PDFInteger pageIndex) : pageIndex(pageIndex) { }
+
+        PDFInteger pageIndex = 0;
+        bool finished = false;
+        PDFPrecompiledPage precompiledPage;
+    };
+
+    State m_state = State::Inactive;
+    QMutex m_mutex;
+    QWaitCondition m_waitCondition;
+    PDFAsynchronousPageCompilerWorkerThread* m_thread = nullptr;
+
+    PDFDrawWidgetProxy* m_proxy;
+    QCache<PDFInteger, PDFPrecompiledPage> m_cache;
+
+    /// This task is protected by mutex. Every access to this
+    /// variable must be done with locked mutex.
+    std::map<PDFInteger, CompileTask> m_tasks;
+};
+
+class PDF4QTLIBWIDGETSSHARED_EXPORT PDFAsynchronousTextLayoutCompiler : public QObject
+{
+    Q_OBJECT
+
+private:
+    using BaseClass = QObject;
+
+public:
+    explicit PDFAsynchronousTextLayoutCompiler(PDFDrawWidgetProxy* proxy);
+
+    /// Starts the engine. Call this function only if the engine
+    /// is stopped.
+    void start();
+
+    /// Stops the engine and all underlying asynchronous tasks. Also
+    /// clears the cache if parameter \p clearCache. Call this function
+    /// only if engine is active. Clear cache should be set to false,
+    /// only if "soft" document update appears (no text on page is being
+    /// changed).
+    /// \param clearCache Clear cache
+    void stop(bool clearCache);
+
+    /// Resets the engine - calls stop and then calls start.
+    void reset();
+
+    enum class State
+    {
+        Inactive,
+        Active,
+        Stopping
+    };
+
+    /// Creates text layout of the page synchronously. If page index is invalid,
+    /// then empty text layout is returned. Compiler must be active to get
+    /// valid text layout.
+    /// \param pageIndex Page index
+    PDFTextLayout createTextLayout(PDFInteger pageIndex);
+
+    /// Returns text layout of the page. If page index is invalid,
+    /// then empty text layout is returned.
+    /// \param pageIndex Page index
+    PDFTextLayout getTextLayout(PDFInteger pageIndex);
+
+    /// Returns getter for text layout of the page. If page index is invalid,
+    /// then empty text layout getter is returned.
+    /// \param pageIndex Page index
+    PDFTextLayoutGetter getTextLayoutLazy(PDFInteger pageIndex);
+
+    /// Select all texts on all pages using \p color color.
+    /// \param color Color to be used for text selection
+    PDFTextSelection getTextSelectionAll(QColor color) const;
+
+    /// Create text layout for the document. Function is asynchronous,
+    /// it returns immediately. After text layout is created, signal
+    /// \p textLayoutChanged is emitted.
+    void makeTextLayout();
+
+    /// Returns true, if text layout is ready
+    bool isTextLayoutReady() const { return m_textLayouts.has_value(); }
+
+    /// Returns text layout storage (if it is ready), or nullptr
+    const PDFTextLayoutStorage* getTextLayoutStorage() const { return isTextLayoutReady() ? &m_textLayouts.value() : nullptr; }
+
+signals:
+    void textLayoutChanged();
+
+private:
+    void onTextLayoutCreated();
+
+    PDFDrawWidgetProxy* m_proxy;
+    State m_state = State::Inactive;
+    bool m_isRunning;
+    std::optional<PDFTextLayoutStorage> m_textLayouts;
+    QFuture<PDFTextLayoutStorage> m_textLayoutCompileFuture;
+    QFutureWatcher<PDFTextLayoutStorage> m_textLayoutCompileFutureWatcher;
+    PDFTextLayoutCache m_cache;
+};
+
+}   // namespace pdf
+
+#endif // PDFCOMPILER_H