File indexing completed on 2024-04-28 04:32:43

 /*
     SPDX-FileCopyrightText: 2005 Piotr Szymanski <niedakh@gmail.com>
     SPDX-FileCopyrightText: 2008 Albert Astals Cid <aacid@kde.org>
 
     Work sponsored by the LiMux project of the city of Munich:
     SPDX-FileCopyrightText: 2017 Klarälvdalens Datakonsult AB a KDAB Group company <info@kdab.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "config-okular.h"
 
 #include "generator.h"
 #include "generator_p.h"
 #include "observer.h"
 
 #include <QApplication>
 #include <QEventLoop>
 #include <QPrinter>
 
 #include <KLocalizedString>
 #include <QDebug>
 #include <QIcon>
 #include <QMimeDatabase>
 #include <QTimer>
 
 #if HAVE_KWALLET
 #include <KWallet>
 #endif
 
 #include "document_p.h"
 #include "page.h"
 #include "page_p.h"
 #include "textpage.h"
 #include "utils.h"
 
 using namespace Okular;
 
 GeneratorPrivate::GeneratorPrivate()
     : m_document(nullptr)
     , mPixmapGenerationThread(nullptr)
     , mTextPageGenerationThread(nullptr)
     , mPixmapReady(true)
     , mTextPageReady(true)
     , m_closing(false)
     , m_closingLoop(nullptr)
     , m_dpi(72.0, 72.0)
 {
     qRegisterMetaType<Okular::Page *>();
 }
 
 GeneratorPrivate::~GeneratorPrivate()
 {
     if (mPixmapGenerationThread) {
         mPixmapGenerationThread->wait();
     }
 
     delete mPixmapGenerationThread;
 
     if (mTextPageGenerationThread) {
         mTextPageGenerationThread->wait();
     }
 
     delete mTextPageGenerationThread;
 }
 
 PixmapGenerationThread *GeneratorPrivate::pixmapGenerationThread()
 {
     if (mPixmapGenerationThread) {
         return mPixmapGenerationThread;
     }
 
     Q_Q(Generator);
     mPixmapGenerationThread = new PixmapGenerationThread(q);
     QObject::connect(
         mPixmapGenerationThread, &PixmapGenerationThread::finished, q, [this] { pixmapGenerationFinished(); }, Qt::QueuedConnection);
 
     return mPixmapGenerationThread;
 }
 
 TextPageGenerationThread *GeneratorPrivate::textPageGenerationThread()
 {
     if (mTextPageGenerationThread) {
         return mTextPageGenerationThread;
     }
 
     Q_Q(Generator);
     mTextPageGenerationThread = new TextPageGenerationThread(q);
     QObject::connect(
         mTextPageGenerationThread, &TextPageGenerationThread::finished, q, [this] { textpageGenerationFinished(); }, Qt::QueuedConnection);
 
     return mTextPageGenerationThread;
 }
 
 void GeneratorPrivate::pixmapGenerationFinished()
 {
     Q_Q(Generator);
     PixmapRequest *request = mPixmapGenerationThread->request();
     const QImage &img = mPixmapGenerationThread->image();
     mPixmapGenerationThread->endGeneration();
 
     QMutexLocker locker(threadsLock());
 
     if (m_closing) {
         mPixmapReady = true;
         delete request;
         if (mTextPageReady) {
             locker.unlock();
             m_closingLoop->quit();
         }
         return;
     }
 
     if (!request->shouldAbortRender()) {
         request->page()->setPixmap(request->observer(), new QPixmap(QPixmap::fromImage(img)), request->normalizedRect());
         const int pageNumber = request->page()->number();
 
         if (mPixmapGenerationThread->calcBoundingBox()) {
             q->updatePageBoundingBox(pageNumber, mPixmapGenerationThread->boundingBox());
         }
     } else {
         // Cancel the text page generation too if it's still running
         if (mTextPageGenerationThread && mTextPageGenerationThread->isRunning()) {
             mTextPageGenerationThread->abortExtraction();
             mTextPageGenerationThread->wait();
         }
     }
 
     mPixmapReady = true;
     q->signalPixmapRequestDone(request);
 }
 
 void GeneratorPrivate::textpageGenerationFinished()
 {
     Q_Q(Generator);
     Page *page = mTextPageGenerationThread->page();
     mTextPageGenerationThread->endGeneration();
 
     QMutexLocker locker(threadsLock());
     mTextPageReady = true;
 
     if (m_closing) {
         delete mTextPageGenerationThread->textPage();
         if (mPixmapReady) {
             locker.unlock();
             m_closingLoop->quit();
         }
         return;
     }
 
     if (mTextPageGenerationThread->textPage()) {
         TextPage *tp = mTextPageGenerationThread->textPage();
         page->setTextPage(tp);
         q->signalTextGenerationDone(page, tp);
     }
 }
 
 QMutex *GeneratorPrivate::threadsLock()
 {
     return &m_threadsMutex;
 }
 
 QVariant GeneratorPrivate::metaData(const QString &, const QVariant &) const
 {
     return QVariant();
 }
 
 QImage GeneratorPrivate::image(PixmapRequest *)
 {
     return QImage();
 }
 
 Generator::Generator(QObject *parent, const QVariantList &args)
     : Generator(*new GeneratorPrivate(), parent, args)
 {
     // the delegated constructor does it all
 }
 
 Generator::Generator(GeneratorPrivate &dd, QObject *parent, const QVariantList &args)
     : QObject(parent)
     , d_ptr(&dd)
 {
     d_ptr->q_ptr = this;
     Q_UNUSED(args)
 }
 
 Generator::~Generator()
 {
     delete d_ptr;
 }
 
 bool Generator::loadDocument(const QString &fileName, QVector<Page *> &pagesVector)
 {
     Q_UNUSED(fileName);
     Q_UNUSED(pagesVector);
 
     return false;
 }
 
 bool Generator::loadDocumentFromData(const QByteArray &, QVector<Page *> &)
 {
     return false;
 }
 
 Document::OpenResult Generator::loadDocumentWithPassword(const QString &fileName, QVector<Page *> &pagesVector, const QString &)
 {
     return loadDocument(fileName, pagesVector) ? Document::OpenSuccess : Document::OpenError;
 }
 
 Document::OpenResult Generator::loadDocumentFromDataWithPassword(const QByteArray &fileData, QVector<Page *> &pagesVector, const QString &)
 {
     return loadDocumentFromData(fileData, pagesVector) ? Document::OpenSuccess : Document::OpenError;
 }
 
 Generator::SwapBackingFileResult Generator::swapBackingFile(QString const & /*newFileName */, QVector<Okular::Page *> & /*newPagesVector*/)
 {
     return SwapBackingFileError;
 }
 
 bool Generator::closeDocument()
 {
     Q_D(Generator);
 
     d->m_closing = true;
 
     d->threadsLock()->lock();
     if (!(d->mPixmapReady && d->mTextPageReady)) {
         QEventLoop loop;
         d->m_closingLoop = &loop;
 
         d->threadsLock()->unlock();
 
         loop.exec();
 
         d->m_closingLoop = nullptr;
     } else {
         d->threadsLock()->unlock();
     }
 
     bool ret = doCloseDocument();
 
     d->m_closing = false;
 
     return ret;
 }
 
 bool Generator::canGeneratePixmap() const
 {
     Q_D(const Generator);
     return d->mPixmapReady;
 }
 
 bool Generator::canSign() const
 {
     return false;
 }
 
 bool Generator::sign(const NewSignatureData &, const QString &)
 {
     return false;
 }
 
 CertificateStore *Generator::certificateStore() const
 {
     return nullptr;
 }
 
 void Generator::generatePixmap(PixmapRequest *request)
 {
     Q_D(Generator);
     d->mPixmapReady = false;
 
     const bool calcBoundingBox = !request->isTile() && !request->page()->isBoundingBoxKnown();
 
     if (request->asynchronous() && hasFeature(Threaded)) {
         if (d->textPageGenerationThread()->isFinished() && !canGenerateTextPage()) {
             // It can happen that the text generation has already finished but
             // mTextPageReady is still false because textpageGenerationFinished
             // didn't have time to run, if so queue ourselves
             QTimer::singleShot(0, this, [this, request] { generatePixmap(request); });
             return;
         }
 
         /**
          * We create the text page for every page that is visible to the
          * user, so he can use the text extraction tools without a delay.
          */
         if (hasFeature(TextExtraction) && !request->page()->hasTextPage() && canGenerateTextPage() && !d->m_closing) {
             d->mTextPageReady = false;
             d->textPageGenerationThread()->setPage(request->page());
 
             // dummy is used as a way to make sure the lambda gets disconnected each time it is executed
             // since not all the times the pixmap generation thread starts we want the text generation thread to also start
             QObject *dummy = new QObject();
             connect(d_ptr->pixmapGenerationThread(), &QThread::started, dummy, [this, dummy] {
                 delete dummy;
                 d_ptr->textPageGenerationThread()->startGeneration();
             });
         }
         // pixmap generation thread must be started *after* connect(), else we may miss the start signal and get lock-ups (see bug 396137)
         d->pixmapGenerationThread()->startGeneration(request, calcBoundingBox);
 
         return;
     }
 
     const QImage &img = image(request);
     request->page()->setPixmap(request->observer(), new QPixmap(QPixmap::fromImage(img)), request->normalizedRect());
     const int pageNumber = request->page()->number();
 
     d->mPixmapReady = true;
 
     signalPixmapRequestDone(request);
     if (calcBoundingBox) {
         updatePageBoundingBox(pageNumber, Utils::imageBoundingBox(&img));
     }
 }
 
 bool Generator::canGenerateTextPage() const
 {
     Q_D(const Generator);
     return d->mTextPageReady;
 }
 
 void Generator::generateTextPage(Page *page)
 {
     TextRequest treq(page);
     TextPage *tp = textPage(&treq);
     page->setTextPage(tp);
     signalTextGenerationDone(page, tp);
 }
 
 QImage Generator::image(PixmapRequest *request)
 {
     Q_D(Generator);
     return d->image(request);
 }
 
 TextPage *Generator::textPage(TextRequest *)
 {
     return nullptr;
 }
 
 DocumentInfo Generator::generateDocumentInfo(const QSet<DocumentInfo::Key> &keys) const
 {
     Q_UNUSED(keys);
 
     return DocumentInfo();
 }
 
 const DocumentSynopsis *Generator::generateDocumentSynopsis()
 {
     return nullptr;
 }
 
 FontInfo::List Generator::fontsForPage(int)
 {
     return FontInfo::List();
 }
 
 const QList<EmbeddedFile *> *Generator::embeddedFiles() const
 {
     return nullptr;
 }
 
 Generator::PageSizeMetric Generator::pagesSizeMetric() const
 {
     return None;
 }
 
 bool Generator::isAllowed(Permission) const
 {
     return true;
 }
 
 void Generator::rotationChanged(Rotation, Rotation)
 {
 }
 
 PageSize::List Generator::pageSizes() const
 {
     return PageSize::List();
 }
 
 void Generator::pageSizeChanged(const PageSize &, const PageSize &)
 {
 }
 
 Document::PrintError Generator::print(QPrinter &)
 {
     return Document::UnknownPrintError;
 }
 
 void Generator::opaqueAction(const BackendOpaqueAction * /*action*/)
 {
 }
 
 void Generator::freeOpaqueActionContents(const BackendOpaqueAction & /*action*/)
 {
 }
 
 QVariant Generator::metaData(const QString &key, const QVariant &option) const
 {
     Q_D(const Generator);
     return d->metaData(key, option);
 }
 
 ExportFormat::List Generator::exportFormats() const
 {
     return ExportFormat::List();
 }
 
 bool Generator::exportTo(const QString &, const ExportFormat &)
 {
     return false;
 }
 
 void Generator::walletDataForFile(const QString &fileName, QString *walletName, QString *walletFolder, QString *walletKey) const
 {
 #if HAVE_KWALLET
     *walletKey = fileName.section(QLatin1Char('/'), -1, -1);
     *walletName = KWallet::Wallet::NetworkWallet();
     *walletFolder = QStringLiteral("KPdf");
 #endif
 }
 
 bool Generator::hasFeature(GeneratorFeature feature) const
 {
     Q_D(const Generator);
     return d->m_features.contains(feature);
 }
 
 void Generator::signalPixmapRequestDone(PixmapRequest *request)
 {
     Q_D(Generator);
     if (d->m_document) {
         d->m_document->requestDone(request);
     } else {
         delete request;
     }
 }
 
 void Generator::signalTextGenerationDone(Page *page, TextPage *textPage)
 {
     Q_D(Generator);
     if (d->m_document) {
         d->m_document->textGenerationDone(page);
     } else {
         delete textPage;
     }
 }
 
 void Generator::signalPartialPixmapRequest(PixmapRequest *request, const QImage &image)
 {
     if (request->shouldAbortRender()) {
         return;
     }
 
     PagePrivate *pagePrivate = PagePrivate::get(request->page());
     pagePrivate->setPixmap(request->observer(), new QPixmap(QPixmap::fromImage(image)), request->normalizedRect(), true /* isPartialPixmap */);
 
     const int pageNumber = request->page()->number();
     request->observer()->notifyPageChanged(pageNumber, Okular::DocumentObserver::Pixmap);
 }
 
 const Document *Generator::document() const
 {
     Q_D(const Generator);
     if (d->m_document) {
         return d->m_document->m_parent;
     }
     return nullptr;
 }
 
 void Generator::setFeature(GeneratorFeature feature, bool on)
 {
     Q_D(Generator);
     if (on) {
         d->m_features.insert(feature);
     } else {
         d->m_features.remove(feature);
     }
 }
 
 QVariant Generator::documentMetaData(const DocumentMetaDataKey key, const QVariant &option) const
 {
     Q_D(const Generator);
     if (!d->m_document) {
         return QVariant();
     }
 
     return d->m_document->documentMetaData(key, option);
 }
 
 QMutex *Generator::userMutex() const
 {
     Q_D(const Generator);
     return &d->m_mutex;
 }
 
 void Generator::updatePageBoundingBox(int page, const NormalizedRect &boundingBox)
 {
     Q_D(Generator);
     if (d->m_document) { // still connected to document?
         d->m_document->setPageBoundingBox(page, boundingBox);
     }
 }
 
 QByteArray Generator::requestFontData(const Okular::FontInfo & /*font*/)
 {
     return {};
 }
 
 void Generator::setDPI(const QSizeF dpi)
 {
     Q_D(Generator);
     d->m_dpi = dpi;
 }
 
 QSizeF Generator::dpi() const
 {
     Q_D(const Generator);
     return d->m_dpi;
 }
 
 QAbstractItemModel *Generator::layersModel() const
 {
     return nullptr;
 }
 
 TextRequest::TextRequest()
     : d(new TextRequestPrivate)
 {
     d->mPage = nullptr;
     d->mShouldAbortExtraction = 0;
 }
 
 TextRequest::TextRequest(Page *page)
     : d(new TextRequestPrivate)
 {
     d->mPage = page;
     d->mShouldAbortExtraction = 0;
 }
 
 TextRequest::~TextRequest()
 {
     delete d;
 }
 
 Page *TextRequest::page() const
 {
     return d->mPage;
 }
 
 bool TextRequest::shouldAbortExtraction() const
 {
     return d->mShouldAbortExtraction != 0;
 }
 
 TextRequestPrivate *TextRequestPrivate::get(const TextRequest *req)
 {
     return req->d;
 }
 
 PixmapRequest::PixmapRequest(DocumentObserver *observer, int pageNumber, int width, int height, qreal dpr, int priority, PixmapRequestFeatures features)
     : d(new PixmapRequestPrivate)
 {
     d->mObserver = observer;
     d->mPageNumber = pageNumber;
     d->mWidth = ceil(width * dpr);
     d->mHeight = ceil(height * dpr);
     d->mPriority = priority;
     d->mFeatures = features;
     d->mForce = false;
     d->mTile = false;
     d->mNormalizedRect = NormalizedRect();
     d->mPartialUpdatesWanted = false;
     d->mShouldAbortRender = 0;
 }
 
 PixmapRequest::~PixmapRequest()
 {
     delete d;
 }
 
 DocumentObserver *PixmapRequest::observer() const
 {
     return d->mObserver;
 }
 
 int PixmapRequest::pageNumber() const
 {
     return d->mPageNumber;
 }
 
 int PixmapRequest::width() const
 {
     return d->mWidth;
 }
 
 int PixmapRequest::height() const
 {
     return d->mHeight;
 }
 
 int PixmapRequest::priority() const
 {
     return d->mPriority;
 }
 
 bool PixmapRequest::asynchronous() const
 {
     return d->mFeatures & Asynchronous;
 }
 
 bool PixmapRequest::preload() const
 {
     return d->mFeatures & Preload;
 }
 
 Page *PixmapRequest::page() const
 {
     return d->mPage;
 }
 
 void PixmapRequest::setTile(bool tile)
 {
     d->mTile = tile;
 }
 
 bool PixmapRequest::isTile() const
 {
     return d->mTile;
 }
 
 void PixmapRequest::setNormalizedRect(const NormalizedRect &rect)
 {
     if (d->mNormalizedRect == rect) {
         return;
     }
 
     d->mNormalizedRect = rect;
 }
 
 const NormalizedRect &PixmapRequest::normalizedRect() const
 {
     return d->mNormalizedRect;
 }
 
 void PixmapRequest::setPartialUpdatesWanted(bool partialUpdatesWanted)
 {
     d->mPartialUpdatesWanted = partialUpdatesWanted;
 }
 
 bool PixmapRequest::partialUpdatesWanted() const
 {
     return d->mPartialUpdatesWanted;
 }
 
 bool PixmapRequest::shouldAbortRender() const
 {
     return d->mShouldAbortRender != 0;
 }
 
 Okular::TilesManager *PixmapRequestPrivate::tilesManager() const
 {
     return mPage->d->tilesManager(mObserver);
 }
 
 PixmapRequestPrivate *PixmapRequestPrivate::get(const PixmapRequest *req)
 {
     return req->d;
 }
 
 void PixmapRequestPrivate::swap()
 {
     std::swap(mWidth, mHeight);
 }
 
 class Okular::ExportFormatPrivate : public QSharedData
 {
 public:
     ExportFormatPrivate(const QString &description, const QMimeType &mimeType, const QIcon &icon = QIcon())
         : QSharedData()
         , mDescription(description)
         , mMimeType(mimeType)
         , mIcon(icon)
     {
     }
     ~ExportFormatPrivate()
     {
     }
 
     QString mDescription;
     QMimeType mMimeType;
     QIcon mIcon;
 };
 
 ExportFormat::ExportFormat()
     : d(new ExportFormatPrivate(QString(), QMimeType()))
 {
 }
 
 ExportFormat::ExportFormat(const QString &description, const QMimeType &mimeType)
     : d(new ExportFormatPrivate(description, mimeType))
 {
 }
 
 ExportFormat::ExportFormat(const QIcon &icon, const QString &description, const QMimeType &mimeType)
     : d(new ExportFormatPrivate(description, mimeType, icon))
 {
 }
 
 ExportFormat::~ExportFormat()
 {
 }
 
 ExportFormat::ExportFormat(const ExportFormat &other)
     : d(other.d)
 {
 }
 
 ExportFormat &ExportFormat::operator=(const ExportFormat &other)
 {
     if (this == &other) {
         return *this;
     }
 
     d = other.d;
 
     return *this;
 }
 
 QString ExportFormat::description() const
 {
     return d->mDescription;
 }
 
 QMimeType ExportFormat::mimeType() const
 {
     return d->mMimeType;
 }
 
 QIcon ExportFormat::icon() const
 {
     return d->mIcon;
 }
 
 bool ExportFormat::isNull() const
 {
     return !d->mMimeType.isValid() || d->mDescription.isNull();
 }
 
 ExportFormat ExportFormat::standardFormat(StandardExportFormat type)
 {
     QMimeDatabase db;
     switch (type) {
     case PlainText:
         return ExportFormat(QIcon::fromTheme(QStringLiteral("text-x-generic")), i18n("Plain &Text..."), db.mimeTypeForName(QStringLiteral("text/plain")));
         break;
     case PDF:
         return ExportFormat(QIcon::fromTheme(QStringLiteral("application-pdf")), i18n("PDF"), db.mimeTypeForName(QStringLiteral("application/pdf")));
         break;
     case OpenDocumentText:
         return ExportFormat(
             QIcon::fromTheme(QStringLiteral("application-vnd.oasis.opendocument.text")), i18nc("This is the document format", "OpenDocument Text"), db.mimeTypeForName(QStringLiteral("application/vnd.oasis.opendocument.text")));
         break;
     case HTML:
         return ExportFormat(QIcon::fromTheme(QStringLiteral("text-html")), i18nc("This is the document format", "HTML"), db.mimeTypeForName(QStringLiteral("text/html")));
         break;
     }
     return ExportFormat();
 }
 
 bool ExportFormat::operator==(const ExportFormat &other) const
 {
     return d == other.d;
 }
 
 bool ExportFormat::operator!=(const ExportFormat &other) const
 {
     return d != other.d;
 }
 
 QDebug operator<<(QDebug str, const Okular::PixmapRequest &req)
 {
     PixmapRequestPrivate *reqPriv = PixmapRequestPrivate::get(&req);
 
     str << "PixmapRequest:" << &req;
     str << "- observer:" << (qulonglong)req.observer();
     str << "- page:" << req.pageNumber();
     str << "- width:" << req.width();
     str << "- height:" << req.height();
     str << "- priority:" << req.priority();
     str << "- async:" << (req.asynchronous() ? "true" : "false");
     str << "- tile:" << (req.isTile() ? "true" : "false");
     str << "- rect:" << req.normalizedRect();
     str << "- preload:" << (req.preload() ? "true" : "false");
     str << "- partialUpdates:" << (req.partialUpdatesWanted() ? "true" : "false");
     str << "- shouldAbort:" << (req.shouldAbortRender() ? "true" : "false");
     str << "- force:" << (reqPriv->mForce ? "true" : "false");
     return str;
 }
 
 /* kate: replace-tabs on; indent-width 4; */