2021-05-24 07:25:56 +00:00
|
|
|
/*
|
|
|
|
SPDX-FileCopyrightText: 2006 Pino Toscano <toscano.pino@tiscali.it>
|
|
|
|
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2006-07-07 14:58:12 +00:00
|
|
|
|
2007-04-19 18:30:20 +00:00
|
|
|
#include "generator_tiff.h"
|
|
|
|
|
2020-07-08 11:54:37 +00:00
|
|
|
#include <QBuffer>
|
|
|
|
#include <QDateTime>
|
|
|
|
#include <QFile>
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <QImage>
|
|
|
|
#include <QList>
|
|
|
|
#include <QPainter>
|
2018-08-31 09:23:45 +00:00
|
|
|
#include <QPrinter>
|
2007-10-15 23:01:27 +00:00
|
|
|
|
2020-07-08 11:54:37 +00:00
|
|
|
#include <KAboutData>
|
2014-10-08 11:37:04 +00:00
|
|
|
#include <KLocalizedString>
|
2018-08-31 09:23:45 +00:00
|
|
|
#include <QDebug>
|
2006-07-07 14:58:12 +00:00
|
|
|
|
2011-06-01 08:49:49 +00:00
|
|
|
#include <core/document.h>
|
|
|
|
#include <core/fileprinter.h>
|
|
|
|
#include <core/page.h>
|
|
|
|
#include <core/utils.h>
|
2007-01-03 14:30:48 +00:00
|
|
|
|
2006-07-07 14:58:12 +00:00
|
|
|
#include <tiff.h>
|
|
|
|
#include <tiffio.h>
|
|
|
|
|
2008-01-25 00:05:57 +00:00
|
|
|
#define TiffDebug 4714
|
|
|
|
|
2008-06-01 09:50:22 +00:00
|
|
|
tsize_t okular_tiffReadProc(thandle_t handle, tdata_t buf, tsize_t size)
|
|
|
|
{
|
|
|
|
QIODevice *device = static_cast<QIODevice *>(handle);
|
|
|
|
return device->isReadable() ? device->read(static_cast<char *>(buf), size) : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
tsize_t okular_tiffWriteProc(thandle_t handle, tdata_t buf, tsize_t size)
|
|
|
|
{
|
|
|
|
QIODevice *device = static_cast<QIODevice *>(handle);
|
|
|
|
return device->write(static_cast<char *>(buf), size);
|
|
|
|
}
|
|
|
|
|
|
|
|
toff_t okular_tiffSeekProc(thandle_t handle, toff_t offset, int whence)
|
|
|
|
{
|
|
|
|
QIODevice *device = static_cast<QIODevice *>(handle);
|
|
|
|
switch (whence) {
|
|
|
|
case SEEK_SET:
|
|
|
|
device->seek(offset);
|
|
|
|
break;
|
|
|
|
case SEEK_CUR:
|
|
|
|
device->seek(device->pos() + offset);
|
|
|
|
break;
|
|
|
|
case SEEK_END:
|
|
|
|
device->seek(device->size() + offset);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return device->pos();
|
|
|
|
}
|
|
|
|
|
|
|
|
int okular_tiffCloseProc(thandle_t handle)
|
|
|
|
{
|
|
|
|
Q_UNUSED(handle)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
toff_t okular_tiffSizeProc(thandle_t handle)
|
|
|
|
{
|
|
|
|
QIODevice *device = static_cast<QIODevice *>(handle);
|
|
|
|
return device->size();
|
|
|
|
}
|
|
|
|
|
|
|
|
int okular_tiffMapProc(thandle_t, tdata_t *, toff_t *)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void okular_tiffUnmapProc(thandle_t, tdata_t, toff_t)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2006-07-07 14:58:12 +00:00
|
|
|
class TIFFGenerator::Private
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Private()
|
2017-09-05 21:27:18 +00:00
|
|
|
: tiff(nullptr)
|
|
|
|
, dev(nullptr)
|
|
|
|
{
|
|
|
|
}
|
2006-07-07 14:58:12 +00:00
|
|
|
|
|
|
|
TIFF *tiff;
|
2008-06-01 09:50:22 +00:00
|
|
|
QByteArray data;
|
|
|
|
QIODevice *dev;
|
2006-07-07 14:58:12 +00:00
|
|
|
};
|
|
|
|
|
2006-07-12 13:33:29 +00:00
|
|
|
static QDateTime convertTIFFDateTime(const char *tiffdate)
|
|
|
|
{
|
|
|
|
if (!tiffdate)
|
|
|
|
return QDateTime();
|
|
|
|
|
2015-10-29 12:37:11 +00:00
|
|
|
return QDateTime::fromString(QString::fromLatin1(tiffdate), QStringLiteral("yyyy:MM:dd HH:mm:ss"));
|
2006-07-12 13:33:29 +00:00
|
|
|
}
|
2006-07-07 14:58:12 +00:00
|
|
|
|
2008-05-31 11:40:49 +00:00
|
|
|
static void adaptSizeToResolution(TIFF *tiff, ttag_t whichres, double dpi, uint32 *size)
|
|
|
|
{
|
|
|
|
float resvalue = 1.0;
|
|
|
|
uint16 resunit = 0;
|
2009-06-15 15:02:52 +00:00
|
|
|
if (!TIFFGetField(tiff, whichres, &resvalue) || !TIFFGetFieldDefaulted(tiff, TIFFTAG_RESOLUTIONUNIT, &resunit))
|
2008-05-31 11:40:49 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
float newsize = *size / resvalue;
|
|
|
|
switch (resunit) {
|
|
|
|
case RESUNIT_INCH:
|
|
|
|
*size = (uint32)(newsize * dpi);
|
|
|
|
break;
|
|
|
|
case RESUNIT_CENTIMETER:
|
|
|
|
*size = (uint32)(newsize * 10.0 / 25.4 * dpi);
|
|
|
|
break;
|
|
|
|
case RESUNIT_NONE:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-01 15:33:54 +00:00
|
|
|
static Okular::Rotation readTiffRotation(TIFF *tiff)
|
|
|
|
{
|
|
|
|
uint32 tiffOrientation = 0;
|
|
|
|
|
|
|
|
if (!TIFFGetField(tiff, TIFFTAG_ORIENTATION, &tiffOrientation))
|
|
|
|
return Okular::Rotation0;
|
|
|
|
|
|
|
|
Okular::Rotation ret = Okular::Rotation0;
|
|
|
|
switch (tiffOrientation) {
|
|
|
|
case ORIENTATION_TOPLEFT:
|
|
|
|
case ORIENTATION_TOPRIGHT:
|
|
|
|
ret = Okular::Rotation0;
|
|
|
|
break;
|
|
|
|
case ORIENTATION_BOTRIGHT:
|
|
|
|
case ORIENTATION_BOTLEFT:
|
|
|
|
ret = Okular::Rotation180;
|
|
|
|
break;
|
|
|
|
case ORIENTATION_LEFTTOP:
|
|
|
|
case ORIENTATION_LEFTBOT:
|
|
|
|
ret = Okular::Rotation270;
|
|
|
|
break;
|
|
|
|
case ORIENTATION_RIGHTTOP:
|
|
|
|
case ORIENTATION_RIGHTBOT:
|
|
|
|
ret = Okular::Rotation90;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-11-28 19:24:41 +00:00
|
|
|
OKULAR_EXPORT_PLUGIN(TIFFGenerator, "libokularGenerator_tiff.json")
|
2007-12-02 20:57:24 +00:00
|
|
|
|
|
|
|
TIFFGenerator::TIFFGenerator(QObject *parent, const QVariantList &args)
|
|
|
|
: Okular::Generator(parent, args)
|
2014-05-11 09:17:49 +00:00
|
|
|
, d(new Private)
|
2007-12-02 20:57:24 +00:00
|
|
|
{
|
|
|
|
setFeature(Threaded);
|
|
|
|
setFeature(PrintNative);
|
|
|
|
setFeature(PrintToFile);
|
2008-06-01 09:57:19 +00:00
|
|
|
setFeature(ReadRawData);
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TIFFGenerator::~TIFFGenerator()
|
|
|
|
{
|
|
|
|
if (d->tiff) {
|
|
|
|
TIFFClose(d->tiff);
|
2017-09-05 21:27:18 +00:00
|
|
|
d->tiff = nullptr;
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
delete d;
|
|
|
|
}
|
|
|
|
|
2006-09-21 08:45:36 +00:00
|
|
|
bool TIFFGenerator::loadDocument(const QString &fileName, QVector<Okular::Page *> &pagesVector)
|
2006-07-14 10:54:29 +00:00
|
|
|
{
|
2008-06-01 09:50:22 +00:00
|
|
|
QFile *qfile = new QFile(fileName);
|
|
|
|
qfile->open(QIODevice::ReadOnly);
|
|
|
|
d->dev = qfile;
|
2008-11-30 18:25:21 +00:00
|
|
|
d->data = QFile::encodeName(QFileInfo(*qfile).fileName());
|
2008-11-30 19:21:23 +00:00
|
|
|
return loadTiff(pagesVector, d->data.constData());
|
2008-06-01 09:57:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool TIFFGenerator::loadDocumentFromData(const QByteArray &fileData, QVector<Okular::Page *> &pagesVector)
|
|
|
|
{
|
|
|
|
d->data = fileData;
|
|
|
|
QBuffer *qbuffer = new QBuffer(&d->data);
|
|
|
|
qbuffer->open(QIODevice::ReadOnly);
|
|
|
|
d->dev = qbuffer;
|
2008-11-30 19:21:23 +00:00
|
|
|
return loadTiff(pagesVector, "<stdin>");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TIFFGenerator::loadTiff(QVector<Okular::Page *> &pagesVector, const char *name)
|
|
|
|
{
|
2008-06-01 09:57:19 +00:00
|
|
|
d->tiff = TIFFClientOpen(name, "r", d->dev, okular_tiffReadProc, okular_tiffWriteProc, okular_tiffSeekProc, okular_tiffCloseProc, okular_tiffSizeProc, okular_tiffMapProc, okular_tiffUnmapProc);
|
|
|
|
if (!d->tiff) {
|
|
|
|
delete d->dev;
|
2017-09-05 21:27:18 +00:00
|
|
|
d->dev = nullptr;
|
2008-06-01 09:57:19 +00:00
|
|
|
d->data.clear();
|
|
|
|
return false;
|
2008-06-01 09:50:22 +00:00
|
|
|
}
|
2006-07-14 10:54:29 +00:00
|
|
|
|
2007-01-05 17:17:30 +00:00
|
|
|
loadPages(pagesVector);
|
2006-07-14 10:54:29 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-10-08 16:46:51 +00:00
|
|
|
bool TIFFGenerator::doCloseDocument()
|
2006-07-07 14:58:12 +00:00
|
|
|
{
|
|
|
|
// closing the old document
|
|
|
|
if (d->tiff) {
|
|
|
|
TIFFClose(d->tiff);
|
2017-09-05 21:27:18 +00:00
|
|
|
d->tiff = nullptr;
|
2008-06-01 09:50:22 +00:00
|
|
|
delete d->dev;
|
2017-09-05 21:27:18 +00:00
|
|
|
d->dev = nullptr;
|
2008-06-01 09:50:22 +00:00
|
|
|
d->data.clear();
|
2008-01-25 00:05:57 +00:00
|
|
|
m_pageMapping.clear();
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-01-24 15:06:45 +00:00
|
|
|
QImage TIFFGenerator::image(Okular::PixmapRequest *request)
|
2006-07-07 14:58:12 +00:00
|
|
|
{
|
|
|
|
bool generated = false;
|
2006-10-28 15:57:58 +00:00
|
|
|
QImage img;
|
2006-07-07 14:58:12 +00:00
|
|
|
|
2008-01-25 00:05:57 +00:00
|
|
|
if (TIFFSetDirectory(d->tiff, mapPage(request->page()->number()))) {
|
2006-10-28 15:57:58 +00:00
|
|
|
int rotation = request->page()->rotation();
|
2008-05-31 11:40:49 +00:00
|
|
|
uint32 width = 1;
|
|
|
|
uint32 height = 1;
|
2008-09-01 15:33:54 +00:00
|
|
|
uint32 orientation = 0;
|
2008-05-31 11:40:49 +00:00
|
|
|
TIFFGetField(d->tiff, TIFFTAG_IMAGEWIDTH, &width);
|
|
|
|
TIFFGetField(d->tiff, TIFFTAG_IMAGELENGTH, &height);
|
2006-07-07 14:58:12 +00:00
|
|
|
|
2008-09-01 15:33:54 +00:00
|
|
|
if (!TIFFGetField(d->tiff, TIFFTAG_ORIENTATION, &orientation))
|
|
|
|
orientation = ORIENTATION_TOPLEFT;
|
|
|
|
|
2006-07-07 14:58:12 +00:00
|
|
|
QImage image(width, height, QImage::Format_RGB32);
|
2020-02-19 15:46:23 +00:00
|
|
|
uint32 *data = reinterpret_cast<uint32 *>(image.bits());
|
2006-07-07 14:58:12 +00:00
|
|
|
|
|
|
|
// read data
|
2008-09-01 15:33:54 +00:00
|
|
|
if (TIFFReadRGBAImageOriented(d->tiff, width, height, data, orientation) != 0) {
|
2006-07-07 14:58:12 +00:00
|
|
|
// an image read by ReadRGBAImage is ABGR, we need ARGB, so swap red and blue
|
|
|
|
uint32 size = width * height;
|
|
|
|
for (uint32 i = 0; i < size; ++i) {
|
|
|
|
uint32 red = (data[i] & 0x00FF0000) >> 16;
|
|
|
|
uint32 blue = (data[i] & 0x000000FF) << 16;
|
|
|
|
data[i] = (data[i] & 0xFF00FF00) + red + blue;
|
|
|
|
}
|
|
|
|
|
2006-10-25 15:35:53 +00:00
|
|
|
int reqwidth = request->width();
|
|
|
|
int reqheight = request->height();
|
2006-07-07 14:58:12 +00:00
|
|
|
if (rotation % 2 == 1)
|
|
|
|
qSwap(reqwidth, reqheight);
|
2006-10-28 15:57:58 +00:00
|
|
|
img = image.scaled(reqwidth, reqheight, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
2006-07-07 14:58:12 +00:00
|
|
|
|
|
|
|
generated = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!generated) {
|
2006-10-28 15:57:58 +00:00
|
|
|
img = QImage(request->width(), request->height(), QImage::Format_RGB32);
|
|
|
|
img.fill(qRgb(255, 255, 255));
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
2007-01-24 15:06:45 +00:00
|
|
|
return img;
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
Okular::DocumentInfo TIFFGenerator::generateDocumentInfo(const QSet<Okular::DocumentInfo::Key> &keys) const
|
2006-07-10 22:52:50 +00:00
|
|
|
{
|
2014-05-11 09:17:49 +00:00
|
|
|
Okular::DocumentInfo docInfo;
|
|
|
|
if (d->tiff) {
|
|
|
|
if (keys.contains(Okular::DocumentInfo::MimeType))
|
2015-10-29 12:37:11 +00:00
|
|
|
docInfo.set(Okular::DocumentInfo::MimeType, QStringLiteral("image/tiff"));
|
2020-07-10 22:15:05 +00:00
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
if (keys.contains(Okular::DocumentInfo::Description)) {
|
2017-09-05 21:27:18 +00:00
|
|
|
char *buffer = nullptr;
|
2014-05-11 09:17:49 +00:00
|
|
|
TIFFGetField(d->tiff, TIFFTAG_IMAGEDESCRIPTION, &buffer);
|
|
|
|
docInfo.set(Okular::DocumentInfo::Description, buffer ? QString::fromLatin1(buffer) : QString());
|
|
|
|
}
|
2006-07-10 22:52:50 +00:00
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
if (keys.contains(Okular::DocumentInfo::Producer)) {
|
2017-09-05 21:27:18 +00:00
|
|
|
char *buffer = nullptr;
|
2014-05-11 09:17:49 +00:00
|
|
|
TIFFGetField(d->tiff, TIFFTAG_SOFTWARE, &buffer);
|
|
|
|
docInfo.set(Okular::DocumentInfo::Producer, buffer ? QString::fromLatin1(buffer) : QString());
|
|
|
|
}
|
2006-07-10 22:52:50 +00:00
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
if (keys.contains(Okular::DocumentInfo::Copyright)) {
|
2017-09-05 21:27:18 +00:00
|
|
|
char *buffer = nullptr;
|
2014-05-11 09:17:49 +00:00
|
|
|
TIFFGetField(d->tiff, TIFFTAG_COPYRIGHT, &buffer);
|
|
|
|
docInfo.set(Okular::DocumentInfo::Copyright, buffer ? QString::fromLatin1(buffer) : QString());
|
|
|
|
}
|
2006-07-10 22:52:50 +00:00
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
if (keys.contains(Okular::DocumentInfo::Author)) {
|
2017-09-05 21:27:18 +00:00
|
|
|
char *buffer = nullptr;
|
2014-05-11 09:17:49 +00:00
|
|
|
TIFFGetField(d->tiff, TIFFTAG_ARTIST, &buffer);
|
|
|
|
docInfo.set(Okular::DocumentInfo::Author, buffer ? QString::fromLatin1(buffer) : QString());
|
|
|
|
}
|
2006-07-10 22:52:50 +00:00
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
if (keys.contains(Okular::DocumentInfo::CreationDate)) {
|
2017-09-05 21:27:18 +00:00
|
|
|
char *buffer = nullptr;
|
2014-05-11 09:17:49 +00:00
|
|
|
TIFFGetField(d->tiff, TIFFTAG_DATETIME, &buffer);
|
|
|
|
QDateTime date = convertTIFFDateTime(buffer);
|
2015-01-29 20:48:47 +00:00
|
|
|
docInfo.set(Okular::DocumentInfo::CreationDate, date.isValid() ? QLocale().toString(date, QLocale::LongFormat) : QString());
|
2014-05-11 09:17:49 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-12 13:33:29 +00:00
|
|
|
|
2014-05-11 09:17:49 +00:00
|
|
|
return docInfo;
|
2006-07-10 22:52:50 +00:00
|
|
|
}
|
|
|
|
|
2007-01-05 17:17:30 +00:00
|
|
|
void TIFFGenerator::loadPages(QVector<Okular::Page *> &pagesVector)
|
2006-07-07 14:58:12 +00:00
|
|
|
{
|
|
|
|
if (!d->tiff)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tdir_t dirs = TIFFNumberOfDirectories(d->tiff);
|
|
|
|
pagesVector.resize(dirs);
|
2008-01-25 00:05:57 +00:00
|
|
|
tdir_t realdirs = 0;
|
2006-07-07 14:58:12 +00:00
|
|
|
|
|
|
|
uint32 width = 0;
|
|
|
|
uint32 height = 0;
|
|
|
|
|
2016-01-30 17:15:07 +00:00
|
|
|
const QSizeF dpi = Okular::Utils::realDpi(nullptr);
|
2006-07-07 14:58:12 +00:00
|
|
|
for (tdir_t i = 0; i < dirs; ++i) {
|
|
|
|
if (!TIFFSetDirectory(d->tiff, i))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (TIFFGetField(d->tiff, TIFFTAG_IMAGEWIDTH, &width) != 1 || TIFFGetField(d->tiff, TIFFTAG_IMAGELENGTH, &height) != 1)
|
|
|
|
continue;
|
|
|
|
|
2016-01-30 17:15:07 +00:00
|
|
|
adaptSizeToResolution(d->tiff, TIFFTAG_XRESOLUTION, dpi.width(), &width);
|
|
|
|
adaptSizeToResolution(d->tiff, TIFFTAG_YRESOLUTION, dpi.height(), &height);
|
2008-05-31 11:40:49 +00:00
|
|
|
|
2008-09-01 15:33:54 +00:00
|
|
|
Okular::Page *page = new Okular::Page(realdirs, width, height, readTiffRotation(d->tiff));
|
2008-01-25 00:05:57 +00:00
|
|
|
pagesVector[realdirs] = page;
|
|
|
|
|
|
|
|
m_pageMapping[realdirs] = i;
|
2006-07-07 14:58:12 +00:00
|
|
|
|
2008-01-25 00:05:57 +00:00
|
|
|
++realdirs;
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
2008-01-25 00:05:57 +00:00
|
|
|
|
|
|
|
pagesVector.resize(realdirs);
|
2006-07-07 14:58:12 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 23:01:27 +00:00
|
|
|
bool TIFFGenerator::print(QPrinter &printer)
|
2006-11-17 15:21:40 +00:00
|
|
|
{
|
|
|
|
uint32 width = 0;
|
|
|
|
uint32 height = 0;
|
|
|
|
|
|
|
|
QPainter p(&printer);
|
|
|
|
|
2007-11-26 21:43:54 +00:00
|
|
|
QList<int> pageList = Okular::FilePrinter::pageList(printer, document()->pages(), document()->currentPage() + 1, document()->bookmarkedPageList());
|
|
|
|
|
2019-12-23 09:59:16 +00:00
|
|
|
for (int i = 0; i < pageList.count(); ++i) {
|
2008-01-25 00:05:57 +00:00
|
|
|
if (!TIFFSetDirectory(d->tiff, mapPage(pageList[i] - 1)))
|
2006-11-17 15:21:40 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (TIFFGetField(d->tiff, TIFFTAG_IMAGEWIDTH, &width) != 1 || TIFFGetField(d->tiff, TIFFTAG_IMAGELENGTH, &height) != 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
QImage image(width, height, QImage::Format_RGB32);
|
2020-02-19 15:46:23 +00:00
|
|
|
uint32 *data = reinterpret_cast<uint32 *>(image.bits());
|
2006-11-17 15:21:40 +00:00
|
|
|
|
|
|
|
// read data
|
|
|
|
if (TIFFReadRGBAImageOriented(d->tiff, width, height, data, ORIENTATION_TOPLEFT) != 0) {
|
|
|
|
// an image read by ReadRGBAImage is ABGR, we need ARGB, so swap red and blue
|
|
|
|
uint32 size = width * height;
|
2019-12-23 09:58:19 +00:00
|
|
|
for (uint32 j = 0; j < size; ++j) {
|
|
|
|
uint32 red = (data[j] & 0x00FF0000) >> 16;
|
|
|
|
uint32 blue = (data[j] & 0x000000FF) << 16;
|
|
|
|
data[j] = (data[j] & 0xFF00FF00) + red + blue;
|
2006-11-17 15:21:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i != 0)
|
|
|
|
printer.newPage();
|
|
|
|
|
2008-11-30 07:41:52 +00:00
|
|
|
QSize targetSize = printer.pageRect().size();
|
|
|
|
|
|
|
|
if ((image.width() < targetSize.width()) && (image.height() < targetSize.height())) {
|
|
|
|
// draw small images at 100% (don't scale up)
|
|
|
|
p.drawImage(0, 0, image);
|
|
|
|
} else {
|
|
|
|
// fit to page
|
|
|
|
p.drawImage(0, 0, image.scaled(targetSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
|
|
|
|
}
|
2006-11-17 15:21:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-01-25 00:05:57 +00:00
|
|
|
int TIFFGenerator::mapPage(int page) const
|
|
|
|
{
|
|
|
|
QHash<int, int>::const_iterator it = m_pageMapping.find(page);
|
|
|
|
if (it == m_pageMapping.end()) {
|
2014-09-11 19:12:27 +00:00
|
|
|
qCWarning(OkularTiffDebug) << "Requesting unmapped page" << page << ":" << m_pageMapping;
|
2008-01-25 00:05:57 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return it.value();
|
|
|
|
}
|
|
|
|
|
2017-01-14 18:19:12 +00:00
|
|
|
Q_LOGGING_CATEGORY(OkularTiffDebug, "org.kde.okular.generators.tiff", QtWarningMsg)
|
2014-09-11 19:12:27 +00:00
|
|
|
|
2006-07-07 14:58:12 +00:00
|
|
|
#include "generator_tiff.moc"
|