641 行
16 KiB
C++
641 行
16 KiB
C++
/*
|
|
|
|
Copyright 2018 S. Razi Alavizadeh
|
|
Copyright 2012-2013, 2015-2018 Adam Reichold
|
|
|
|
This file is part of qpdfview.
|
|
|
|
qpdfview 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 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
qpdfview 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 qpdfview. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
#include "pluginhandler.h"
|
|
|
|
#include <QApplication>
|
|
#include <QDebug>
|
|
#include <QDir>
|
|
#include <QFileInfo>
|
|
#include <QImageReader>
|
|
#include <QMessageBox>
|
|
#include <QPluginLoader>
|
|
#include <QProcess>
|
|
#include <QTemporaryFile>
|
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
|
|
|
|
#include <QMimeDatabase>
|
|
|
|
#endif // QT_VERSION
|
|
|
|
#ifdef WITH_MAGIC
|
|
|
|
#include <magic.h>
|
|
|
|
#endif // WITH_MAGIC
|
|
|
|
#include "model.h"
|
|
|
|
namespace
|
|
{
|
|
|
|
using namespace qpdfview;
|
|
|
|
Plugin* loadStaticPlugin(const QString& objectName)
|
|
{
|
|
foreach(QObject* object, QPluginLoader::staticInstances())
|
|
{
|
|
if(object->objectName() == objectName)
|
|
{
|
|
if(Plugin* plugin = qobject_cast< Plugin* >(object))
|
|
{
|
|
return plugin;
|
|
}
|
|
}
|
|
}
|
|
|
|
qCritical() << "Could not load static plug-in:" << objectName;
|
|
|
|
return 0;
|
|
}
|
|
|
|
Plugin* loadPlugin(const QString& fileName)
|
|
{
|
|
QPluginLoader pluginLoader;
|
|
|
|
#ifdef PLUGIN_RESOLVE_ALL
|
|
|
|
pluginLoader.setLoadHints(QLibrary::ResolveAllSymbolsHint);
|
|
|
|
#endif // PLUGIN_RESOLVE_ALL
|
|
|
|
const QString localFileName = QDir(QApplication::applicationDirPath()).absoluteFilePath(fileName);
|
|
pluginLoader.setFileName(localFileName);
|
|
|
|
if(!pluginLoader.load())
|
|
{
|
|
const QString localErrorString = pluginLoader.errorString();
|
|
|
|
const QString globalFileName = QDir(PLUGIN_INSTALL_PATH).absoluteFilePath(fileName);
|
|
pluginLoader.setFileName(globalFileName);
|
|
|
|
if(!pluginLoader.load())
|
|
{
|
|
const QString globalErrorString = pluginLoader.errorString();
|
|
|
|
qCritical() << "Could not load local plug-in:" << localFileName;
|
|
qCritical() << localErrorString;
|
|
|
|
qCritical() << "Could not load global plug-in:" << globalFileName;
|
|
qCritical() << globalErrorString;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
Plugin* plugin = qobject_cast< Plugin* >(pluginLoader.instance());
|
|
|
|
if(plugin == 0)
|
|
{
|
|
qCritical() << "Could not instantiate plug-in:" << pluginLoader.fileName();
|
|
qCritical() << pluginLoader.errorString();
|
|
}
|
|
|
|
return plugin;
|
|
}
|
|
|
|
QStringList supportedImageFormats()
|
|
{
|
|
QStringList formats;
|
|
|
|
foreach(const QByteArray& format, QImageReader::supportedImageFormats())
|
|
{
|
|
const QString name = QString::fromLocal8Bit(format);
|
|
|
|
formats.append(QLatin1String("*.") + name.toLower());
|
|
formats.append(QLatin1String("*.") + name.toUpper());
|
|
}
|
|
|
|
return formats;
|
|
}
|
|
|
|
struct MimeTypeMapping
|
|
{
|
|
const char* mimeType;
|
|
PluginHandler::FileType fileType;
|
|
const char* suffix;
|
|
const char* alternativeSuffix;
|
|
};
|
|
|
|
const MimeTypeMapping mimeTypeMappings[] =
|
|
{
|
|
{ "application/pdf", PluginHandler::PDF, "pdf", 0 },
|
|
{ "application/postscript", PluginHandler::PS, "ps", "eps" },
|
|
{ "image/vnd.djvu", PluginHandler::DjVu, "djvu", "djv" },
|
|
{ "application/x-gzip", PluginHandler::GZip, "gz", 0 },
|
|
{ "application/x-bzip2", PluginHandler::BZip2, "bz2", 0 },
|
|
{ "application/x-xz", PluginHandler::XZ, "xz", 0 },
|
|
{ "application/epub+zip", PluginHandler::EPUB, "epub", 0 },
|
|
{ "application/x-fictionbook+xml", PluginHandler::FB2, "fb2", 0 },
|
|
{ "application/x-zip-compressed-fb2", PluginHandler::FB2, "fb2", 0 },
|
|
{ "application/zip", PluginHandler::ZIP, "zip", 0 }
|
|
};
|
|
|
|
const MimeTypeMapping* const endOfMimeTypeMappings = mimeTypeMappings + sizeof(mimeTypeMappings) / sizeof(mimeTypeMappings[0]);
|
|
|
|
void matchArchiveAndImageType(const QString& filePath, PluginHandler::FileType& fileType)
|
|
{
|
|
if(fileType == PluginHandler::ZIP)
|
|
{
|
|
const QString suffix = QFileInfo(filePath).suffix().toLower();
|
|
|
|
if (suffix == "cbz")
|
|
{
|
|
fileType = PluginHandler::CBZ;
|
|
}
|
|
else if (suffix == "xps" || suffix == "oxps")
|
|
{
|
|
fileType = PluginHandler::XPS;
|
|
}
|
|
else
|
|
{
|
|
fileType = PluginHandler::Unknown;
|
|
}
|
|
}
|
|
|
|
if(fileType == PluginHandler::Unknown && !QImageReader::imageFormat(filePath).isEmpty())
|
|
{
|
|
fileType = PluginHandler::Image;
|
|
}
|
|
}
|
|
|
|
PluginHandler::FileType matchFileType(const QString& filePath)
|
|
{
|
|
PluginHandler::FileType fileType = PluginHandler::Unknown;
|
|
|
|
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
|
|
|
|
const QMimeType mimeType = QMimeDatabase().mimeTypeForFile(filePath, QMimeDatabase::MatchContent);
|
|
|
|
for(const MimeTypeMapping* mapping = mimeTypeMappings; mapping != endOfMimeTypeMappings; ++mapping)
|
|
{
|
|
if(mimeType.inherits(mapping->mimeType))
|
|
{
|
|
fileType = mapping->fileType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
matchArchiveAndImageType(filePath, fileType);
|
|
|
|
if(fileType == PluginHandler::Unknown)
|
|
{
|
|
qDebug() << "Unknown MIME type:" << mimeType.name();
|
|
}
|
|
|
|
#else
|
|
|
|
#ifdef WITH_MAGIC
|
|
|
|
magic_t cookie = magic_open(MAGIC_MIME_TYPE | MAGIC_SYMLINK);
|
|
|
|
if(magic_load(cookie, 0) == 0)
|
|
{
|
|
const char* const mimeType = magic_file(cookie, QFile::encodeName(filePath));
|
|
|
|
for(const MimeTypeMapping* mapping = mimeTypeMappings; mapping != endOfMimeTypeMappings; ++mapping)
|
|
{
|
|
if(qstrcmp(mimeType, mapping->mimeType) == 0)
|
|
{
|
|
fileType = mapping->fileType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
matchArchiveAndImageType(filePath, fileType);
|
|
|
|
if(fileType == PluginHandler::Unknown)
|
|
{
|
|
qDebug() << "Unknown MIME type:" << mimeType;
|
|
}
|
|
}
|
|
|
|
magic_close(cookie);
|
|
|
|
#else
|
|
|
|
const QString suffix = QFileInfo(filePath).suffix().toLower();
|
|
|
|
for(const MimeTypeMapping* mapping = mimeTypeMappings; mapping != endOfMimeTypeMappings; ++mapping)
|
|
{
|
|
if(suffix == mapping->suffix || (mapping->alternativeSuffix != 0 && suffix == mapping->alternativeSuffix))
|
|
{
|
|
fileType = mapping->fileType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
matchArchiveAndImageType(filePath, fileType);
|
|
|
|
if(fileType == PluginHandler::Unknown)
|
|
{
|
|
qDebug() << "Unkown file suffix:" << suffix;
|
|
}
|
|
|
|
#endif // WITH_MAGIC
|
|
|
|
#endif // QT_VERSION
|
|
|
|
return fileType;
|
|
}
|
|
|
|
int execute(QProcess& process, const QString& program, const QStringList& arguments = QStringList())
|
|
{
|
|
process.start(program, arguments, QIODevice::NotOpen);
|
|
|
|
if(!process.waitForStarted())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if(!process.waitForFinished())
|
|
{
|
|
return -2;
|
|
}
|
|
|
|
return process.exitCode();
|
|
}
|
|
|
|
QStringList supportedCompressedFormats()
|
|
{
|
|
QStringList formats;
|
|
|
|
QProcess process;
|
|
process.setStandardInputFile("/dev/null");
|
|
process.setStandardOutputFile("/dev/null");
|
|
|
|
if(execute(process, "gzip") >= 0)
|
|
{
|
|
formats.append("*.gz *.GZ");
|
|
}
|
|
|
|
if(execute(process, "bzip2") >= 0)
|
|
{
|
|
formats.append("*.bz2 *.BZ2");
|
|
}
|
|
|
|
if(execute(process, "xz") >= 0)
|
|
{
|
|
formats.append("*.xz *.XZ");
|
|
}
|
|
|
|
return formats;
|
|
}
|
|
|
|
QString decompressToTemporaryFile(const QString& filePath, const PluginHandler::FileType fileType)
|
|
{
|
|
const char* command;
|
|
|
|
switch(fileType)
|
|
{
|
|
case PluginHandler::GZip:
|
|
command = "gzip";
|
|
break;
|
|
case PluginHandler::BZip2:
|
|
command = "bzip2";
|
|
break;
|
|
case PluginHandler::XZ:
|
|
command = "xz";
|
|
break;
|
|
default:
|
|
return QString();
|
|
}
|
|
|
|
QTemporaryFile file;
|
|
file.setAutoRemove(false);
|
|
|
|
if(!file.open())
|
|
{
|
|
return QString();
|
|
}
|
|
|
|
file.close();
|
|
|
|
QProcess process;
|
|
process.setStandardInputFile("/dev/null");
|
|
process.setStandardOutputFile(file.fileName());
|
|
|
|
if(execute(process, command, QStringList() << "-dck" << filePath) != 0)
|
|
{
|
|
return QString();
|
|
}
|
|
|
|
return file.fileName();
|
|
}
|
|
|
|
} // anonymous
|
|
|
|
namespace qpdfview
|
|
{
|
|
|
|
PluginHandler* PluginHandler::s_instance = 0;
|
|
|
|
PluginHandler* PluginHandler::instance()
|
|
{
|
|
if(s_instance == 0)
|
|
{
|
|
s_instance = new PluginHandler(qApp);
|
|
}
|
|
|
|
return s_instance;
|
|
}
|
|
|
|
PluginHandler::~PluginHandler()
|
|
{
|
|
s_instance = 0;
|
|
}
|
|
|
|
QLatin1String PluginHandler::fileTypeName(PluginHandler::FileType fileType)
|
|
{
|
|
switch(fileType)
|
|
{
|
|
default:
|
|
case PluginHandler::Unknown:
|
|
return QLatin1String("Unknown");
|
|
case PluginHandler::PDF:
|
|
return QLatin1String("PDF");
|
|
case PluginHandler::PS:
|
|
return QLatin1String("PS");
|
|
case PluginHandler::DjVu:
|
|
return QLatin1String("DjVu");
|
|
case PluginHandler::Image:
|
|
return QLatin1String("Image");
|
|
case PluginHandler::EPUB:
|
|
return QLatin1String("EPUB");
|
|
case PluginHandler::XPS:
|
|
return QLatin1String("XPS");
|
|
case PluginHandler::FB2:
|
|
return QLatin1String("FictionBook2");
|
|
case PluginHandler::CBZ:
|
|
return QLatin1String("CBZ");
|
|
case PluginHandler::GZip:
|
|
case PluginHandler::BZip2:
|
|
case PluginHandler::XZ:
|
|
case PluginHandler::ZIP:
|
|
return QLatin1String("Compressed");
|
|
}
|
|
}
|
|
|
|
QStringList PluginHandler::openFilter()
|
|
{
|
|
QStringList openFilter;
|
|
QStringList supportedFormats;
|
|
|
|
#if defined(WITH_PDF) || defined(WITH_FITZ)
|
|
|
|
openFilter.append(QLatin1String("Portable document format (*.pdf *.PDF)"));
|
|
supportedFormats.append(QLatin1String("*.pdf *.PDF"));
|
|
|
|
#endif // WITH_PDF // WITH_FITZ
|
|
|
|
#if defined(WITH_FITZ)
|
|
|
|
openFilter.append(QLatin1String("EPUB (*.epub *.EPUB)"));
|
|
supportedFormats.append(QLatin1String("*.epub *.EPUB"));
|
|
|
|
openFilter.append(QLatin1String("XPS (*.xps *.XPS *.oxps *.OXPS)"));
|
|
supportedFormats.append(QLatin1String("*.xps *.XPS *.oxps *.OXPS"));
|
|
|
|
openFilter.append(QLatin1String("FictionBook 2 (*.fb2 *.FB2)"));
|
|
supportedFormats.append(QLatin1String("*.fb2 *.FB2"));
|
|
|
|
openFilter.append(QLatin1String("CBZ (*.cbz *.CBZ)"));
|
|
supportedFormats.append(QLatin1String("*.cbz *.CBZ"));
|
|
|
|
#endif // WITH_FITZ
|
|
|
|
#ifdef WITH_PS
|
|
|
|
openFilter.append(QLatin1String("PostScript (*.ps *.PS)"));
|
|
openFilter.append(QLatin1String("Encapsulated PostScript (*.eps *.EPS)"));
|
|
supportedFormats.append(QLatin1String("*.ps *.PS *.eps *.EPS"));
|
|
|
|
#endif // WITH_PS
|
|
|
|
#ifdef WITH_DJVU
|
|
|
|
openFilter.append(QLatin1String("DjVu (*.djvu *.DJVU *.djv *.DJV)"));
|
|
supportedFormats.append(QLatin1String("*.djvu *.DJVU *.djv *.DJV"));
|
|
|
|
#endif // WITH_DJVU
|
|
|
|
#ifdef WITH_IMAGE
|
|
|
|
static QStringList imageFormats;
|
|
|
|
if(imageFormats.isEmpty())
|
|
{
|
|
imageFormats = supportedImageFormats();
|
|
}
|
|
|
|
if(!imageFormats.isEmpty())
|
|
{
|
|
openFilter.append(tr("Image (%1)").arg(imageFormats.join(QLatin1String(" "))));
|
|
supportedFormats.append(imageFormats);
|
|
}
|
|
|
|
#endif // WITH_IMAGE
|
|
|
|
static QStringList compressedFormats;
|
|
|
|
if(compressedFormats.isEmpty())
|
|
{
|
|
compressedFormats = supportedCompressedFormats();
|
|
}
|
|
|
|
if(!compressedFormats.isEmpty())
|
|
{
|
|
openFilter.append(tr("Compressed (%1)").arg(compressedFormats.join(QLatin1String(" "))));
|
|
supportedFormats.append(compressedFormats);
|
|
}
|
|
|
|
openFilter.prepend(tr("Supported formats (%1)").arg(supportedFormats.join(QLatin1String(" "))));
|
|
|
|
return openFilter;
|
|
}
|
|
|
|
Model::Document* PluginHandler::loadDocument(const QString& filePath)
|
|
{
|
|
FileType fileType = matchFileType(filePath);
|
|
QString adjustedFilePath = filePath;
|
|
|
|
if(fileType == GZip || fileType == BZip2 || fileType == XZ)
|
|
{
|
|
adjustedFilePath = decompressToTemporaryFile(filePath, fileType);
|
|
|
|
if(adjustedFilePath.isEmpty())
|
|
{
|
|
qWarning() << tr("Could not decompress '%1'!").arg(filePath);
|
|
|
|
return 0;
|
|
}
|
|
|
|
fileType = matchFileType(adjustedFilePath);
|
|
}
|
|
|
|
if(fileType == Unknown)
|
|
{
|
|
qWarning() << tr("Could not match file type of '%1'!").arg(filePath);
|
|
|
|
return 0;
|
|
}
|
|
|
|
if(!loadPlugin(fileType))
|
|
{
|
|
QMessageBox::critical(0, tr("Critical"), tr("Could not load plug-in for file type '%1'!").arg(fileTypeName(fileType)));
|
|
|
|
return 0;
|
|
}
|
|
|
|
return m_plugins.value(fileType)->loadDocument(adjustedFilePath);
|
|
}
|
|
|
|
SettingsWidget* PluginHandler::createSettingsWidget(FileType fileType, QWidget* parent)
|
|
{
|
|
return loadPlugin(fileType) ? m_plugins.value(fileType)->createSettingsWidget(parent) : 0;
|
|
}
|
|
|
|
PluginHandler::PluginHandler(QObject* parent) : QObject(parent),
|
|
m_plugins()
|
|
{
|
|
#ifdef WITH_IMAGE
|
|
#ifdef STATIC_IMAGE_PLUGIN
|
|
m_objectNames.insertMulti(Image, QLatin1String("ImagePlugin"));
|
|
#else
|
|
m_fileNames.insertMulti(Image, QLatin1String(IMAGE_PLUGIN_NAME));
|
|
#endif // STATIC_IMAGE_PLUGIN
|
|
#endif // WITH_IMAGE
|
|
|
|
#ifdef WITH_FITZ
|
|
#ifdef STATIC_FITZ_PLUGIN
|
|
m_objectNames.insertMulti(PDF, QLatin1String("FitzPlugin"));
|
|
m_objectNames.insertMulti(EPUB, QLatin1String("FitzPlugin"));
|
|
m_objectNames.insertMulti(XPS, QLatin1String("FitzPlugin"));
|
|
m_objectNames.insertMulti(FB2, QLatin1String("FitzPlugin"));
|
|
m_objectNames.insertMulti(CBZ, QLatin1String("FitzPlugin"));
|
|
#else
|
|
m_fileNames.insertMulti(PDF, QLatin1String(FITZ_PLUGIN_NAME));
|
|
m_fileNames.insertMulti(EPUB, QLatin1String(FITZ_PLUGIN_NAME));
|
|
m_fileNames.insertMulti(XPS, QLatin1String(FITZ_PLUGIN_NAME));
|
|
m_fileNames.insertMulti(FB2, QLatin1String(FITZ_PLUGIN_NAME));
|
|
m_fileNames.insertMulti(CBZ, QLatin1String(FITZ_PLUGIN_NAME));
|
|
#endif // STATIC_FITZ_PLUGIN
|
|
#endif // WITH_FITZ
|
|
|
|
#ifdef WITH_PDF
|
|
#ifdef STATIC_PDF_PLUGIN
|
|
m_objectNames.insertMulti(PDF, QLatin1String("PdfPlugin"));
|
|
#else
|
|
m_fileNames.insertMulti(PDF, QLatin1String(PDF_PLUGIN_NAME));
|
|
#endif // STATIC_PDF_PLUGIN
|
|
#endif // WITH_PDF
|
|
|
|
#ifdef WITH_PS
|
|
#ifdef STATIC_PS_PLUGIN
|
|
m_objectNames.insertMulti(PS, QLatin1String("PsPlugin"));
|
|
#else
|
|
m_fileNames.insertMulti(PS, QLatin1String(PS_PLUGIN_NAME));
|
|
#endif // STATIC_PS_PLUGIN
|
|
#endif // WITH_PS
|
|
|
|
#ifdef WITH_DJVU
|
|
#ifdef STATIC_DJVU_PLUGIN
|
|
m_objectNames.insertMulti(DjVu, QLatin1String("DjVuPlugin"));
|
|
#else
|
|
m_fileNames.insertMulti(DjVu, QLatin1String(DJVU_PLUGIN_NAME));
|
|
#endif // STATIC_DJVU_PLUGIN
|
|
#endif // WITH_DJVU
|
|
}
|
|
|
|
bool PluginHandler::loadPlugin(FileType fileType)
|
|
{
|
|
if(m_plugins.contains(fileType))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
foreach(const QString& objectName, m_objectNames.values(fileType))
|
|
{
|
|
if(Plugin* plugin = ::loadStaticPlugin(objectName))
|
|
{
|
|
m_plugins.insert(fileType, plugin);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
foreach(const QString& fileName, m_fileNames.values(fileType))
|
|
{
|
|
if(Plugin* plugin = ::loadPlugin(fileName))
|
|
{
|
|
m_plugins.insert(fileType, plugin);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
} // qpdfview
|
|
|
|
#ifdef STATIC_IMAGE_PLUGIN
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
|
|
Q_IMPORT_PLUGIN(qpdfview_image)
|
|
#else
|
|
Q_IMPORT_PLUGIN(ImagePlugin)
|
|
#endif // QT_VERSION
|
|
#endif // STATIC_IMAGE_PLUGIN
|
|
|
|
#ifdef STATIC_FITZ_PLUGIN
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
|
|
Q_IMPORT_PLUGIN(qpdfview_fitz)
|
|
#else
|
|
Q_IMPORT_PLUGIN(FitzPlugin)
|
|
#endif // QT_VERSION
|
|
#endif // STATIC_FITZ_PLUGIN
|
|
|
|
#ifdef STATIC_PDF_PLUGIN
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
|
|
Q_IMPORT_PLUGIN(qpdfview_pdf)
|
|
#else
|
|
Q_IMPORT_PLUGIN(PdfPlugin)
|
|
#endif // QT_VERSION
|
|
#endif // STATIC_PDF_PLUGIN
|
|
|
|
#ifdef STATIC_PS_PLUGIN
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
|
|
Q_IMPORT_PLUGIN(qpdfview_ps)
|
|
#else
|
|
Q_IMPORT_PLUGIN(PsPlugin)
|
|
#endif // QT_VERSION
|
|
#endif // STATIC_PS_PLUGIN
|
|
|
|
#ifdef STATIC_DJVU_PLUGIN
|
|
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
|
|
Q_IMPORT_PLUGIN(qpdfview_djvu)
|
|
#else
|
|
Q_IMPORT_PLUGIN(DjVuPlugin)
|
|
#endif // QT_VERSION
|
|
#endif // STATIC_DJVU_PLUGIN
|