mirror of
https://invent.kde.org/graphics/okular
synced 2024-08-27 11:40:07 +00:00
805 lines
19 KiB
C++
805 lines
19 KiB
C++
/*
|
|
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; */
|