Google Git
Sign in
skia / third_party / poppler / d8ae3ba659c71b4f5913ecf74d525461bb831366 / . / qt6 / src / poppler-annotation.cc
blob: 1a3c8130cea7fc97d5b6e541db46e2cff87e9966 [file] [log] [blame]
/* poppler-annotation.cc: qt interface to poppler
* Copyright (C) 2006, 2009, 2012-2015, 2018-2022 Albert Astals Cid <aacid@kde.org>
* Copyright (C) 2006, 2008, 2010 Pino Toscano <pino@kde.org>
* Copyright (C) 2012, Guillermo A. Amaral B. <gamaral@kde.org>
* Copyright (C) 2012-2014 Fabio D'Urso <fabiodurso@hotmail.it>
* Copyright (C) 2012, 2015, Tobias Koenig <tobias.koenig@kdab.com>
* Copyright (C) 2018 Adam Reichold <adam.reichold@t-online.de>
* Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by the LiMux project of the city of Munich
* Copyright (C) 2018 Intevation GmbH <intevation@intevation.de>
* Copyright (C) 2018 Dileep Sankhla <sankhla.dileep96@gmail.com>
* Copyright (C) 2018, 2019 Tobias Deiminger <haxtibal@posteo.de>
* Copyright (C) 2018 Carlos Garcia Campos <carlosgc@gnome.org>
* Copyright (C) 2020-2022 Oliver Sander <oliver.sander@tu-dresden.de>
* Copyright (C) 2020 Katarina Behrens <Katarina.Behrens@cib.de>
* Copyright (C) 2020 Thorsten Behrens <Thorsten.Behrens@CIB.de>
* Copyright (C) 2020 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by Technische Universität Dresden
* Copyright (C) 2021 Mahmoud Ahmed Khalil <mahmoudkhalil11@gmail.com>
* Adapting code from
* Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>
*
* This program 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, or (at your option)
* any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
*/
// qt/kde includes
#include <QtCore/QtAlgorithms>
#include <QtGui/QColor>
#include <QtGui/QTransform>
#include <QImage>
// local includes
#include "poppler-annotation.h"
#include "poppler-link.h"
#include "poppler-qt6.h"
#include "poppler-annotation-helper.h"
#include "poppler-annotation-private.h"
#include "poppler-page-private.h"
#include "poppler-private.h"
// poppler includes
#include <Page.h>
#include <Annot.h>
#include <Gfx.h>
#include <Error.h>
#include <FileSpec.h>
#include <Link.h>
#include <DateInfo.h>
/* Almost all getters directly query the underlying poppler annotation, with
* the exceptions of link, file attachment, sound, movie and screen annotations,
* Whose data retrieval logic has not been moved yet. Their getters return
* static data set at creation time by findAnnotations
*/
namespace Poppler {
// BEGIN AnnotationAppearancePrivate implementation
AnnotationAppearancePrivate::AnnotationAppearancePrivate(Annot *annot)
{
if (annot) {
appearance = annot->getAppearance();
} else {
appearance.setToNull();
}
}
// END AnnotationAppearancePrivate implementation
// BEGIN AnnotationAppearance implementation
AnnotationAppearance::AnnotationAppearance(AnnotationAppearancePrivate *annotationAppearancePrivate) : d(annotationAppearancePrivate) { }
AnnotationAppearance::~AnnotationAppearance()
{
delete d;
}
// END AnnotationAppearance implementation
// BEGIN Annotation implementation
AnnotationPrivate::AnnotationPrivate() : revisionScope(Annotation::Root), revisionType(Annotation::None), pdfAnnot(nullptr), pdfPage(nullptr), parentDoc(nullptr) { }
void getRawDataFromQImage(const QImage &qimg, int bitsPerPixel, QByteArray *data, QByteArray *sMaskData)
{
const int height = qimg.height();
const int width = qimg.width();
switch (bitsPerPixel) {
case 1:
for (int line = 0; line < height; line++) {
const char *lineData = reinterpret_cast<const char *>(qimg.scanLine(line));
for (int offset = 0; offset < (width + 7) / 8; offset++) {
data->append(lineData[offset]);
}
}
break;
case 8:
case 24:
data->append((const char *)qimg.bits(), static_cast<int>(qimg.sizeInBytes()));
break;
case 32:
for (int line = 0; line < height; line++) {
const QRgb *lineData = reinterpret_cast<const QRgb *>(qimg.scanLine(line));
for (int offset = 0; offset < width; offset++) {
char a = (char)qAlpha(lineData[offset]);
char r = (char)qRed(lineData[offset]);
char g = (char)qGreen(lineData[offset]);
char b = (char)qBlue(lineData[offset]);
data->append(r);
data->append(g);
data->append(b);
sMaskData->append(a);
}
}
break;
}
}
void AnnotationPrivate::addRevision(Annotation *ann, Annotation::RevScope scope, Annotation::RevType type)
{
/* Since ownership stays with the caller, create an alias of ann */
revisions.append(ann->d_ptr->makeAlias());
/* Set revision properties */
revisionScope = scope;
revisionType = type;
}
AnnotationPrivate::~AnnotationPrivate()
{
// Delete all children revisions
qDeleteAll(revisions);
// Release Annot object
if (pdfAnnot) {
pdfAnnot->decRefCnt();
}
}
void AnnotationPrivate::tieToNativeAnnot(Annot *ann, ::Page *page, Poppler::DocumentData *doc)
{
if (pdfAnnot) {
error(errIO, -1, "Annotation is already tied");
return;
}
pdfAnnot = ann;
pdfPage = page;
parentDoc = doc;
pdfAnnot->incRefCnt();
}
/* This method is called when a new annotation is created, after pdfAnnot and
* pdfPage have been set */
void AnnotationPrivate::flushBaseAnnotationProperties()
{
Q_ASSERT(pdfPage);
Annotation *q = makeAlias(); // Setters are defined in the public class
// Since pdfAnnot has been set, this calls will write in the Annot object
q->setAuthor(author);
q->setContents(contents);
q->setUniqueName(uniqueName);
q->setModificationDate(modDate);
q->setCreationDate(creationDate);
q->setFlags(flags);
// q->setBoundary(boundary); -- already set by subclass-specific code
q->setStyle(style);
q->setPopup(popup);
// Flush revisions
foreach (Annotation *r, revisions) {
// TODO: Flush revision
delete r; // Object is no longer needed
}
delete q;
// Clear some members to save memory
author.clear();
contents.clear();
uniqueName.clear();
revisions.clear();
}
// Returns matrix to convert from user space coords (oriented according to the
// specified rotation) to normalized coords
static void fillNormalizationMTX(::Page *pdfPage, double MTX[6], int pageRotation)
{
Q_ASSERT(pdfPage);
// build a normalized transform matrix for this page at 100% scale
GfxState *gfxState = new GfxState(72.0, 72.0, pdfPage->getCropBox(), pageRotation, true);
const double *gfxCTM = gfxState->getCTM();
double w = pdfPage->getCropWidth();
double h = pdfPage->getCropHeight();
// Swap width and height if the page is rotated landscape or seascape
if (pageRotation == 90 || pageRotation == 270) {
double t = w;
w = h;
h = t;
}
for (int i = 0; i < 6; i += 2) {
MTX[i] = gfxCTM[i] / w;
MTX[i + 1] = gfxCTM[i + 1] / h;
}
delete gfxState;
}
// Returns matrix to convert from user space coords (i.e. those that are stored
// in the PDF file) to normalized coords (i.e. those that we expose to clients).
// This method also applies a rotation around the top-left corner if the
// FixedRotation flag is set.
void AnnotationPrivate::fillTransformationMTX(double MTX[6]) const
{
Q_ASSERT(pdfPage);
Q_ASSERT(pdfAnnot);
const int pageRotate = pdfPage->getRotate();
if (pageRotate == 0 || (pdfAnnot->getFlags() & Annot::flagNoRotate) == 0) {
// Use the normalization matrix for this page's rotation
fillNormalizationMTX(pdfPage, MTX, pageRotate);
} else {
// Clients expect coordinates relative to this page's rotation, but
// FixedRotation annotations internally use unrotated coordinates:
// construct matrix to both normalize and rotate coordinates using the
// top-left corner as rotation pivot
double MTXnorm[6];
fillNormalizationMTX(pdfPage, MTXnorm, pageRotate);
QTransform transform(MTXnorm[0], MTXnorm[1], MTXnorm[2], MTXnorm[3], MTXnorm[4], MTXnorm[5]);
transform.translate(+pdfAnnot->getXMin(), +pdfAnnot->getYMax());
transform.rotate(pageRotate);
transform.translate(-pdfAnnot->getXMin(), -pdfAnnot->getYMax());
MTX[0] = transform.m11();
MTX[1] = transform.m12();
MTX[2] = transform.m21();
MTX[3] = transform.m22();
MTX[4] = transform.dx();
MTX[5] = transform.dy();
}
}
QRectF AnnotationPrivate::fromPdfRectangle(const PDFRectangle &r) const
{
double swp, MTX[6];
fillTransformationMTX(MTX);
QPointF p1, p2;
XPDFReader::transform(MTX, r.x1, r.y1, p1);
XPDFReader::transform(MTX, r.x2, r.y2, p2);
double tl_x = p1.x();
double tl_y = p1.y();
double br_x = p2.x();
double br_y = p2.y();
if (tl_x > br_x) {
swp = tl_x;
tl_x = br_x;
br_x = swp;
}
if (tl_y > br_y) {
swp = tl_y;
tl_y = br_y;
br_y = swp;
}
return QRectF(QPointF(tl_x, tl_y), QPointF(br_x, br_y));
}
// This function converts a boundary QRectF in normalized coords to a
// PDFRectangle in user coords. If the FixedRotation flag is set, this function
// also applies a rotation around the top-left corner: it's the inverse of
// the transformation produced by fillTransformationMTX, but we can't use
// fillTransformationMTX here because it relies on the native annotation
// object's boundary rect to be already set up.
PDFRectangle boundaryToPdfRectangle(::Page *pdfPage, const QRectF &r, int rFlags)
{
Q_ASSERT(pdfPage);
const int pageRotate = pdfPage->getRotate();
double MTX[6];
fillNormalizationMTX(pdfPage, MTX, pageRotate);
double tl_x, tl_y, br_x, br_y, swp;
XPDFReader::invTransform(MTX, r.topLeft(), tl_x, tl_y);
XPDFReader::invTransform(MTX, r.bottomRight(), br_x, br_y);
if (tl_x > br_x) {
swp = tl_x;
tl_x = br_x;
br_x = swp;
}
if (tl_y > br_y) {
swp = tl_y;
tl_y = br_y;
br_y = swp;
}
const int rotationFixUp = (rFlags & Annotation::FixedRotation) ? pageRotate : 0;
const double width = br_x - tl_x;
const double height = br_y - tl_y;
if (rotationFixUp == 0) {
return PDFRectangle(tl_x, tl_y, br_x, br_y);
} else if (rotationFixUp == 90) {
return PDFRectangle(tl_x, tl_y - width, tl_x + height, tl_y);
} else if (rotationFixUp == 180) {
return PDFRectangle(br_x, tl_y - height, br_x + width, tl_y);
} else { // rotationFixUp == 270
return PDFRectangle(br_x, br_y - width, br_x + height, br_y);
}
}
PDFRectangle AnnotationPrivate::boundaryToPdfRectangle(const QRectF &r, int rFlags) const
{
return Poppler::boundaryToPdfRectangle(pdfPage, r, rFlags);
}
AnnotPath *AnnotationPrivate::toAnnotPath(const QVector<QPointF> &list) const
{
const int count = list.size();
std::vector<AnnotCoord> ac;
ac.reserve(count);
double MTX[6];
fillTransformationMTX(MTX);
foreach (const QPointF &p, list) {
double x, y;
XPDFReader::invTransform(MTX, p, x, y);
ac.emplace_back(x, y);
}
return new AnnotPath(std::move(ac));
}
std::vector<std::unique_ptr<Annotation>> AnnotationPrivate::findAnnotations(::Page *pdfPage, DocumentData *doc, const QSet<Annotation::SubType> &subtypes, int parentID)
{
Annots *annots = pdfPage->getAnnots();
const bool wantTextAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AText);
const bool wantLineAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::ALine);
const bool wantGeomAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AGeom);
const bool wantHighlightAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AHighlight);
const bool wantStampAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AStamp);
const bool wantInkAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AInk);
const bool wantLinkAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::ALink);
const bool wantCaretAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::ACaret);
const bool wantFileAttachmentAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AFileAttachment);
const bool wantSoundAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::ASound);
const bool wantMovieAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AMovie);
const bool wantScreenAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AScreen);
const bool wantWidgetAnnotations = subtypes.isEmpty() || subtypes.contains(Annotation::AWidget);
// Create Annotation objects and tie to their native Annot
std::vector<std::unique_ptr<Annotation>> res;
for (Annot *ann : annots->getAnnots()) {
if (!ann) {
error(errInternal, -1, "Annot is null");
continue;
}
// Check parent annotation
AnnotMarkup *markupann = dynamic_cast<AnnotMarkup *>(ann);
if (!markupann) {
// Assume it's a root annotation, and skip if user didn't request it
if (parentID != -1) {
continue;
}
} else if (markupann->getInReplyToID() != parentID) {
continue;
}
/* Create Annotation of the right subclass */
std::unique_ptr<Annotation> annotation;
Annot::AnnotSubtype subType = ann->getType();
switch (subType) {
case Annot::typeText:
if (!wantTextAnnotations) {
continue;
}
annotation = std::make_unique<TextAnnotation>(TextAnnotation::Linked);
break;
case Annot::typeFreeText:
if (!wantTextAnnotations) {
continue;
}
annotation = std::make_unique<TextAnnotation>(TextAnnotation::InPlace);
break;
case Annot::typeLine:
if (!wantLineAnnotations) {
continue;
}
annotation = std::make_unique<LineAnnotation>(LineAnnotation::StraightLine);
break;
case Annot::typePolygon:
case Annot::typePolyLine:
if (!wantLineAnnotations) {
continue;
}
annotation = std::make_unique<LineAnnotation>(LineAnnotation::Polyline);
break;
case Annot::typeSquare:
case Annot::typeCircle:
if (!wantGeomAnnotations) {
continue;
}
annotation = std::make_unique<GeomAnnotation>();
break;
case Annot::typeHighlight:
case Annot::typeUnderline:
case Annot::typeSquiggly:
case Annot::typeStrikeOut:
if (!wantHighlightAnnotations) {
continue;
}
annotation = std::make_unique<HighlightAnnotation>();
break;
case Annot::typeStamp:
if (!wantStampAnnotations) {
continue;
}
annotation = std::make_unique<StampAnnotation>();
break;
case Annot::typeInk:
if (!wantInkAnnotations) {
continue;
}
annotation = std::make_unique<InkAnnotation>();
break;
case Annot::typeLink: /* TODO: Move logic to getters */
{
if (!wantLinkAnnotations) {
continue;
}
// parse Link params
AnnotLink *linkann = static_cast<AnnotLink *>(ann);
LinkAnnotation *l = new LinkAnnotation();
// -> hlMode
l->setLinkHighlightMode((LinkAnnotation::HighlightMode)linkann->getLinkEffect());
// -> link region
// TODO
// reading link action
if (linkann->getAction()) {
std::unique_ptr<Link> popplerLink = PageData::convertLinkActionToLink(linkann->getAction(), doc, QRectF());
if (popplerLink) {
l->setLinkDestination(std::move(popplerLink));
}
}
annotation.reset(l);
break;
}
case Annot::typeCaret:
if (!wantCaretAnnotations) {
continue;
}
annotation = std::make_unique<CaretAnnotation>();
break;
case Annot::typeFileAttachment: /* TODO: Move logic to getters */
{
if (!wantFileAttachmentAnnotations) {
continue;
}
AnnotFileAttachment *attachann = static_cast<AnnotFileAttachment *>(ann);
FileAttachmentAnnotation *f = new FileAttachmentAnnotation();
// -> fileIcon
f->setFileIconName(QString::fromLatin1(attachann->getName()->c_str()));
// -> embeddedFile
auto filespec = std::make_unique<FileSpec>(attachann->getFile());
f->setEmbeddedFile(new EmbeddedFile(*new EmbeddedFileData(std::move(filespec))));
annotation.reset(f);
break;
}
case Annot::typeSound: /* TODO: Move logic to getters */
{
if (!wantSoundAnnotations) {
continue;
}
AnnotSound *soundann = static_cast<AnnotSound *>(ann);
SoundAnnotation *s = new SoundAnnotation();
// -> soundIcon
s->setSoundIconName(QString::fromLatin1(soundann->getName()->c_str()));
// -> sound
s->setSound(new SoundObject(soundann->getSound()));
annotation.reset(s);
break;
}
case Annot::typeMovie: /* TODO: Move logic to getters */
{
if (!wantMovieAnnotations) {
continue;
}
AnnotMovie *movieann = static_cast<AnnotMovie *>(ann);
MovieAnnotation *m = new MovieAnnotation();
// -> movie
MovieObject *movie = new MovieObject(movieann);
m->setMovie(movie);
// -> movieTitle
const GooString *movietitle = movieann->getTitle();
if (movietitle) {
m->setMovieTitle(QString::fromLatin1(movietitle->c_str()));
}
annotation.reset(m);
break;
}
case Annot::typeScreen: {
if (!wantScreenAnnotations) {
continue;
}
AnnotScreen *screenann = static_cast<AnnotScreen *>(ann);
// TODO Support other link types than Link::Rendition in ScreenAnnotation
if (!screenann->getAction() || screenann->getAction()->getKind() != actionRendition) {
continue;
}
ScreenAnnotation *s = new ScreenAnnotation();
// -> screen
std::unique_ptr<Link> popplerLink = PageData::convertLinkActionToLink(screenann->getAction(), doc, QRectF());
s->setAction(static_cast<Poppler::LinkRendition *>(popplerLink.release()));
// -> screenTitle
const GooString *screentitle = screenann->getTitle();
if (screentitle) {
s->setScreenTitle(UnicodeParsedString(screentitle));
}
annotation.reset(s);
break;
}
case Annot::typePopup:
continue; // popups are parsed by Annotation's window() getter
case Annot::typeUnknown:
continue; // special case for ignoring unknown annotations
case Annot::typeWidget:
if (!wantWidgetAnnotations) {
continue;
}
annotation.reset(new WidgetAnnotation());
break;
case Annot::typeRichMedia: {
const AnnotRichMedia *annotRichMedia = static_cast<AnnotRichMedia *>(ann);
RichMediaAnnotation *richMediaAnnotation = new RichMediaAnnotation;
const AnnotRichMedia::Settings *annotSettings = annotRichMedia->getSettings();
if (annotSettings) {
RichMediaAnnotation::Settings *settings = new RichMediaAnnotation::Settings;
if (annotSettings->getActivation()) {
RichMediaAnnotation::Activation *activation = new RichMediaAnnotation::Activation;
switch (annotSettings->getActivation()->getCondition()) {
case AnnotRichMedia::Activation::conditionPageOpened:
activation->setCondition(RichMediaAnnotation::Activation::PageOpened);
break;
case AnnotRichMedia::Activation::conditionPageVisible:
activation->setCondition(RichMediaAnnotation::Activation::PageVisible);
break;
case AnnotRichMedia::Activation::conditionUserAction:
activation->setCondition(RichMediaAnnotation::Activation::UserAction);
break;
}
settings->setActivation(activation);
}
if (annotSettings->getDeactivation()) {
RichMediaAnnotation::Deactivation *deactivation = new RichMediaAnnotation::Deactivation;
switch (annotSettings->getDeactivation()->getCondition()) {
case AnnotRichMedia::Deactivation::conditionPageClosed:
deactivation->setCondition(RichMediaAnnotation::Deactivation::PageClosed);
break;
case AnnotRichMedia::Deactivation::conditionPageInvisible:
deactivation->setCondition(RichMediaAnnotation::Deactivation::PageInvisible);
break;
case AnnotRichMedia::Deactivation::conditionUserAction:
deactivation->setCondition(RichMediaAnnotation::Deactivation::UserAction);
break;
}
settings->setDeactivation(deactivation);
}
richMediaAnnotation->setSettings(settings);
}
const AnnotRichMedia::Content *annotContent = annotRichMedia->getContent();
if (annotContent) {
RichMediaAnnotation::Content *content = new RichMediaAnnotation::Content;
const int configurationsCount = annotContent->getConfigurationsCount();
if (configurationsCount > 0) {
QList<RichMediaAnnotation::Configuration *> configurations;
for (int i = 0; i < configurationsCount; ++i) {
const AnnotRichMedia::Configuration *annotConfiguration = annotContent->getConfiguration(i);
if (!annotConfiguration) {
continue;
}
RichMediaAnnotation::Configuration *configuration = new RichMediaAnnotation::Configuration;
if (annotConfiguration->getName()) {
configuration->setName(UnicodeParsedString(annotConfiguration->getName()));
}
switch (annotConfiguration->getType()) {
case AnnotRichMedia::Configuration::type3D:
configuration->setType(RichMediaAnnotation::Configuration::Type3D);
break;
case AnnotRichMedia::Configuration::typeFlash:
configuration->setType(RichMediaAnnotation::Configuration::TypeFlash);
break;
case AnnotRichMedia::Configuration::typeSound:
configuration->setType(RichMediaAnnotation::Configuration::TypeSound);
break;
case AnnotRichMedia::Configuration::typeVideo:
configuration->setType(RichMediaAnnotation::Configuration::TypeVideo);
break;
}
const int instancesCount = annotConfiguration->getInstancesCount();
if (instancesCount > 0) {
QList<RichMediaAnnotation::Instance *> instances;
for (int j = 0; j < instancesCount; ++j) {
const AnnotRichMedia::Instance *annotInstance = annotConfiguration->getInstance(j);
if (!annotInstance) {
continue;
}
RichMediaAnnotation::Instance *instance = new RichMediaAnnotation::Instance;
switch (annotInstance->getType()) {
case AnnotRichMedia::Instance::type3D:
instance->setType(RichMediaAnnotation::Instance::Type3D);
break;
case AnnotRichMedia::Instance::typeFlash:
instance->setType(RichMediaAnnotation::Instance::TypeFlash);
break;
case AnnotRichMedia::Instance::typeSound:
instance->setType(RichMediaAnnotation::Instance::TypeSound);
break;
case AnnotRichMedia::Instance::typeVideo:
instance->setType(RichMediaAnnotation::Instance::TypeVideo);
break;
}
const AnnotRichMedia::Params *annotParams = annotInstance->getParams();
if (annotParams) {
RichMediaAnnotation::Params *params = new RichMediaAnnotation::Params;
if (annotParams->getFlashVars()) {
params->setFlashVars(UnicodeParsedString(annotParams->getFlashVars()));
}
instance->setParams(params);
}
instances.append(instance);
}
configuration->setInstances(instances);
}
configurations.append(configuration);
}
content->setConfigurations(configurations);
}
const int assetsCount = annotContent->getAssetsCount();
if (assetsCount > 0) {
QList<RichMediaAnnotation::Asset *> assets;
for (int i = 0; i < assetsCount; ++i) {
const AnnotRichMedia::Asset *annotAsset = annotContent->getAsset(i);
if (!annotAsset) {
continue;
}
RichMediaAnnotation::Asset *asset = new RichMediaAnnotation::Asset;
if (annotAsset->getName()) {
asset->setName(UnicodeParsedString(annotAsset->getName()));
}
auto fileSpec = std::make_unique<FileSpec>(annotAsset->getFileSpec());
asset->setEmbeddedFile(new EmbeddedFile(*new EmbeddedFileData(std::move(fileSpec))));
assets.append(asset);
}
content->setAssets(assets);
}
richMediaAnnotation->setContent(content);
}
annotation.reset(richMediaAnnotation);
break;
}
default: {
#define CASE_FOR_TYPE(thetype) \
case Annot::type##thetype: \
error(errUnimplemented, -1, "Annotation " #thetype " not supported"); \
break;
switch (subType) {
CASE_FOR_TYPE(PrinterMark)
CASE_FOR_TYPE(TrapNet)
CASE_FOR_TYPE(Watermark)
CASE_FOR_TYPE(3D)
default:
error(errUnimplemented, -1, "Annotation {0:d} not supported", subType);
}
continue;
#undef CASE_FOR_TYPE
}
}
annotation->d_ptr->tieToNativeAnnot(ann, pdfPage, doc);
res.push_back(std::move(annotation));
}
return res;
}
Ref AnnotationPrivate::pdfObjectReference() const
{
if (pdfAnnot == nullptr) {
return Ref::INVALID();
}
return pdfAnnot->getRef();
}
std::unique_ptr<Link> AnnotationPrivate::additionalAction(Annotation::AdditionalActionType type) const
{
if (pdfAnnot->getType() != Annot::typeScreen && pdfAnnot->getType() != Annot::typeWidget) {
return {};
}
const Annot::AdditionalActionsType actionType = toPopplerAdditionalActionType(type);
std::unique_ptr<::LinkAction> linkAction;
if (pdfAnnot->getType() == Annot::typeScreen) {
linkAction = static_cast<AnnotScreen *>(pdfAnnot)->getAdditionalAction(actionType);
} else {
linkAction = static_cast<AnnotWidget *>(pdfAnnot)->getAdditionalAction(actionType);
}
if (linkAction) {
return PageData::convertLinkActionToLink(linkAction.get(), parentDoc, QRectF());
}
return {};
}
void AnnotationPrivate::addAnnotationToPage(::Page *pdfPage, DocumentData *doc, const Annotation *ann)
{
if (ann->d_ptr->pdfAnnot != nullptr) {
error(errIO, -1, "Annotation is already tied");
return;
}
// Unimplemented annotations can't be created by the user because their ctor
// is private. Therefore, createNativeAnnot will never return 0
Annot *nativeAnnot = ann->d_ptr->createNativeAnnot(pdfPage, doc);
Q_ASSERT(nativeAnnot);
if (ann->d_ptr->annotationAppearance.isStream()) {
nativeAnnot->setNewAppearance(ann->d_ptr->annotationAppearance.copy());
}
pdfPage->addAnnot(nativeAnnot);
}
void AnnotationPrivate::removeAnnotationFromPage(::Page *pdfPage, const Annotation *ann)
{
if (ann->d_ptr->pdfAnnot == nullptr) {
error(errIO, -1, "Annotation is not tied");
return;
}
if (ann->d_ptr->pdfPage != pdfPage) {
error(errIO, -1, "Annotation doesn't belong to the specified page");
return;
}
// Remove annotation
pdfPage->removeAnnot(ann->d_ptr->pdfAnnot);
// Destroy object
delete ann;
}
class TextAnnotationPrivate : public AnnotationPrivate
{
public:
TextAnnotationPrivate();
Annotation *makeAlias() override;
Annot *createNativeAnnot(::Page *destPage, DocumentData *doc) override;
void setDefaultAppearanceToNative();
std::unique_ptr<DefaultAppearance> getDefaultAppearanceFromNative() const;
// data fields
TextAnnotation::TextType textType;
QString textIcon;
std::optional<QFont> textFont;
QColor textColor = Qt::black;
TextAnnotation::InplaceAlignPosition inplaceAlign;
QVector<QPointF> inplaceCallout;
TextAnnotation::InplaceIntent inplaceIntent;
};
class Annotation::Style::Private : public QSharedData
{
public:
Private() : opacity(1.0), width(1.0), lineStyle(Solid), xCorners(0.0), yCorners(0.0), lineEffect(NoEffect), effectIntensity(1.0)
{
dashArray.resize(1);
dashArray[0] = 3;
}
QColor color;
double opacity;
double width;
Annotation::LineStyle lineStyle;
double xCorners;
double yCorners;
QVector<double> dashArray;
Annotation::LineEffect lineEffect;
double effectIntensity;
};
Annotation::Style::Style() : d(new Private) { }
Annotation::Style::Style(const Style &other) : d(other.d) { }
Annotation::Style &Annotation::Style::operator=(const Style &other)
{
if (this != &other) {
d = other.d;
}
return *this;
}
Annotation::Style::~Style() { }
QColor Annotation::Style::color() const
{
return d->color;
}
void Annotation::Style::setColor(const QColor &color)
{
d->color = color;
}
double Annotation::Style::opacity() const
{
return d->opacity;
}
void Annotation::Style::setOpacity(double opacity)
{
d->opacity = opacity;
}
double Annotation::Style::width() const
{
return d->width;
}
void Annotation::Style::setWidth(double width)
{
d->width = width;
}
Annotation::LineStyle Annotation::Style::lineStyle() const
{
return d->lineStyle;
}
void Annotation::Style::setLineStyle(Annotation::LineStyle style)
{
d->lineStyle = style;
}
double Annotation::Style::xCorners() const
{
return d->xCorners;
}
void Annotation::Style::setXCorners(double radius)
{
d->xCorners = radius;
}
double Annotation::Style::yCorners() const
{
return d->yCorners;
}
void Annotation::Style::setYCorners(double radius)
{
d->yCorners = radius;
}
const QVector<double> &Annotation::Style::dashArray() const
{
return d->dashArray;
}
void Annotation::Style::setDashArray(const QVector<double> &array)
{
d->dashArray = array;
}
Annotation::LineEffect Annotation::Style::lineEffect() const
{
return d->lineEffect;
}
void Annotation::Style::setLineEffect(Annotation::LineEffect effect)
{
d->lineEffect = effect;
}
double Annotation::Style::effectIntensity() const
{
return d->effectIntensity;
}
void Annotation::Style::setEffectIntensity(double intens)
{
d->effectIntensity = intens;
}
class Annotation::Popup::Private : public QSharedData
{
public:
Private() : flags(-1) { }
int flags;
QRectF geometry;
QString title;
QString summary;
QString text;
};
Annotation::Popup::Popup() : d(new Private) { }
Annotation::Popup::Popup(const Popup &other) : d(other.d) { }
Annotation::Popup &Annotation::Popup::operator=(const Popup &other)
{
if (this != &other) {
d = other.d;
}
return *this;
}
Annotation::Popup::~Popup() { }
int Annotation::Popup::flags() const
{
return d->flags;
}
void Annotation::Popup::setFlags(int flags)
{
d->flags = flags;
}
QRectF Annotation::Popup::geometry() const
{
return d->geometry;
}
void Annotation::Popup::setGeometry(const QRectF &geom)
{
d->geometry = geom;
}
QString Annotation::Popup::title() const
{
return d->title;
}
void Annotation::Popup::setTitle(const QString &title)
{
d->title = title;
}
QString Annotation::Popup::summary() const
{
return d->summary;
}
void Annotation::Popup::setSummary(const QString &summary)
{
d->summary = summary;
}
QString Annotation::Popup::text() const
{
return d->text;
}
void Annotation::Popup::setText(const QString &text)
{
d->text = text;
}
Annotation::Annotation(AnnotationPrivate &dd) : d_ptr(&dd) { }
Annotation::~Annotation() { }
QString Annotation::author() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->author;
}
const AnnotMarkup *markupann = dynamic_cast<const AnnotMarkup *>(d->pdfAnnot);
return markupann ? UnicodeParsedString(markupann->getLabel()) : QString();
}
void Annotation::setAuthor(const QString &author)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->author = author;
return;
}
AnnotMarkup *markupann = dynamic_cast<AnnotMarkup *>(d->pdfAnnot);
if (markupann) {
markupann->setLabel(std::unique_ptr<GooString>(QStringToUnicodeGooString(author)));
}
}
QString Annotation::contents() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->contents;
}
return UnicodeParsedString(d->pdfAnnot->getContents());
}
void Annotation::setContents(const QString &contents)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->contents = contents;
return;
}
d->pdfAnnot->setContents(std::unique_ptr<GooString>(QStringToUnicodeGooString(contents)));
TextAnnotationPrivate *textAnnotD = dynamic_cast<TextAnnotationPrivate *>(d);
if (textAnnotD) {
textAnnotD->setDefaultAppearanceToNative();
}
}
QString Annotation::uniqueName() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->uniqueName;
}
return UnicodeParsedString(d->pdfAnnot->getName());
}
void Annotation::setUniqueName(const QString &uniqueName)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->uniqueName = uniqueName;
return;
}
QByteArray ascii = uniqueName.toLatin1();
GooString s(ascii.constData());
d->pdfAnnot->setName(&s);
}
QDateTime Annotation::modificationDate() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->modDate;
}
if (d->pdfAnnot->getModified()) {
return convertDate(d->pdfAnnot->getModified()->c_str());
} else {
return QDateTime();
}
}
void Annotation::setModificationDate(const QDateTime &date)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->modDate = date;
return;
}
if (d->pdfAnnot) {
if (date.isValid()) {
const time_t t = date.toSecsSinceEpoch();
GooString *s = timeToDateString(&t);
d->pdfAnnot->setModified(s);
delete s;
} else {
d->pdfAnnot->setModified(nullptr);
}
}
}
QDateTime Annotation::creationDate() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->creationDate;
}
const AnnotMarkup *markupann = dynamic_cast<const AnnotMarkup *>(d->pdfAnnot);
if (markupann && markupann->getDate()) {
return convertDate(markupann->getDate()->c_str());
}
return modificationDate();
}
void Annotation::setCreationDate(const QDateTime &date)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->creationDate = date;
return;
}
AnnotMarkup *markupann = dynamic_cast<AnnotMarkup *>(d->pdfAnnot);
if (markupann) {
if (date.isValid()) {
const time_t t = date.toSecsSinceEpoch();
GooString *s = timeToDateString(&t);
markupann->setDate(s);
delete s;
} else {
markupann->setDate(nullptr);
}
}
}
static Annotation::Flags fromPdfFlags(int flags)
{
Annotation::Flags qtflags;
if (flags & Annot::flagHidden) {
qtflags |= Annotation::Hidden;
}
if (flags & Annot::flagNoZoom) {
qtflags |= Annotation::FixedSize;
}
if (flags & Annot::flagNoRotate) {
qtflags |= Annotation::FixedRotation;
}
if (!(flags & Annot::flagPrint)) {
qtflags |= Annotation::DenyPrint;
}
if (flags & Annot::flagReadOnly) {
qtflags |= Annotation::DenyWrite;
qtflags |= Annotation::DenyDelete;
}
if (flags & Annot::flagLocked) {
qtflags |= Annotation::DenyDelete;
}
if (flags & Annot::flagToggleNoView) {
qtflags |= Annotation::ToggleHidingOnMouse;
}
return qtflags;
}
static int toPdfFlags(Annotation::Flags qtflags)
{
int flags = 0;
if (qtflags & Annotation::Hidden) {
flags |= Annot::flagHidden;
}
if (qtflags & Annotation::FixedSize) {
flags |= Annot::flagNoZoom;
}
if (qtflags & Annotation::FixedRotation) {
flags |= Annot::flagNoRotate;
}
if (!(qtflags & Annotation::DenyPrint)) {
flags |= Annot::flagPrint;
}
if (qtflags & Annotation::DenyWrite) {
flags |= Annot::flagReadOnly;
}
if (qtflags & Annotation::DenyDelete) {
flags |= Annot::flagLocked;
}
if (qtflags & Annotation::ToggleHidingOnMouse) {
flags |= Annot::flagToggleNoView;
}
return flags;
}
Annotation::Flags Annotation::flags() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->flags;
}
return fromPdfFlags(d->pdfAnnot->getFlags());
}
void Annotation::setFlags(Annotation::Flags flags)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->flags = flags;
return;
}
d->pdfAnnot->setFlags(toPdfFlags(flags));
}
QRectF Annotation::boundary() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->boundary;
}
const PDFRectangle &rect = d->pdfAnnot->getRect();
return d->fromPdfRectangle(rect);
}
void Annotation::setBoundary(const QRectF &boundary)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->boundary = boundary;
return;
}
const PDFRectangle rect = d->boundaryToPdfRectangle(boundary, flags());
if (rect == d->pdfAnnot->getRect()) {
return;
}
d->pdfAnnot->setRect(&rect);
}
Annotation::Style Annotation::style() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->style;
}
Style s;
s.setColor(convertAnnotColor(d->pdfAnnot->getColor()));
const AnnotMarkup *markupann = dynamic_cast<const AnnotMarkup *>(d->pdfAnnot);
if (markupann) {
s.setOpacity(markupann->getOpacity());
}
const AnnotBorder *border = d->pdfAnnot->getBorder();
if (border) {
if (border->getType() == AnnotBorder::typeArray) {
const AnnotBorderArray *border_array = static_cast<const AnnotBorderArray *>(border);
s.setXCorners(border_array->getHorizontalCorner());
s.setYCorners(border_array->getVerticalCorner());
}
s.setWidth(border->getWidth());
s.setLineStyle((Annotation::LineStyle)(1 << border->getStyle()));
const std::vector<double> &dashArray = border->getDash();
s.setDashArray(QVector<double>(dashArray.begin(), dashArray.end()));
}
AnnotBorderEffect *border_effect;
switch (d->pdfAnnot->getType()) {
case Annot::typeFreeText:
border_effect = static_cast<AnnotFreeText *>(d->pdfAnnot)->getBorderEffect();
break;
case Annot::typeSquare:
case Annot::typeCircle:
border_effect = static_cast<AnnotGeometry *>(d->pdfAnnot)->getBorderEffect();
break;
default:
border_effect = nullptr;
}
if (border_effect) {
s.setLineEffect((Annotation::LineEffect)border_effect->getEffectType());
s.setEffectIntensity(border_effect->getIntensity());
}
return s;
}
void Annotation::setStyle(const Annotation::Style &style)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->style = style;
return;
}
d->pdfAnnot->setColor(convertQColor(style.color()));
AnnotMarkup *markupann = dynamic_cast<AnnotMarkup *>(d->pdfAnnot);
if (markupann) {
markupann->setOpacity(style.opacity());
}
auto border = std::make_unique<AnnotBorderArray>();
border->setWidth(style.width());
border->setHorizontalCorner(style.xCorners());
border->setVerticalCorner(style.yCorners());
d->pdfAnnot->setBorder(std::move(border));
}
Annotation::Popup Annotation::popup() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->popup;
}
Popup w;
AnnotPopup *popup = nullptr;
int flags = -1; // Not initialized
const AnnotMarkup *markupann = dynamic_cast<const AnnotMarkup *>(d->pdfAnnot);
if (markupann) {
popup = markupann->getPopup();
w.setSummary(UnicodeParsedString(markupann->getSubject()));
}
if (popup) {
flags = fromPdfFlags(popup->getFlags()) & (Annotation::Hidden | Annotation::FixedSize | Annotation::FixedRotation);
if (!popup->getOpen()) {
flags |= Annotation::Hidden;
}
const PDFRectangle &rect = popup->getRect();
w.setGeometry(d->fromPdfRectangle(rect));
}
if (d->pdfAnnot->getType() == Annot::typeText) {
const AnnotText *textann = static_cast<const AnnotText *>(d->pdfAnnot);
// Text annotations default to same rect as annotation
if (flags == -1) {
flags = 0;
w.setGeometry(boundary());
}
// If text is not 'opened', force window hiding. if the window
// was parsed from popup, the flag should already be set
if (!textann->getOpen() && flags != -1) {
flags |= Annotation::Hidden;
}
}
w.setFlags(flags);
return w;
}
void Annotation::setPopup(const Annotation::Popup &popup)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->popup = popup;
return;
}
#if 0 /* TODO: Remove old popup and add AnnotPopup to page */
AnnotMarkup *markupann = dynamic_cast<AnnotMarkup*>(d->pdfAnnot);
if (!markupann)
return;
// Create a new AnnotPopup and assign it to pdfAnnot
PDFRectangle rect = d->toPdfRectangle( popup.geometry() );
AnnotPopup * p = new AnnotPopup( d->pdfPage->getDoc(), &rect );
p->setOpen( !(popup.flags() & Annotation::Hidden) );
if (!popup.summary().isEmpty())
{
GooString *s = QStringToUnicodeGooString(popup.summary());
markupann->setLabel(s);
delete s;
}
markupann->setPopup(p);
#endif
}
Annotation::RevScope Annotation::revisionScope() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->revisionScope;
}
const AnnotMarkup *markupann = dynamic_cast<const AnnotMarkup *>(d->pdfAnnot);
if (markupann && markupann->isInReplyTo()) {
switch (markupann->getReplyTo()) {
case AnnotMarkup::replyTypeR:
return Annotation::Reply;
case AnnotMarkup::replyTypeGroup:
return Annotation::Group;
}
}
return Annotation::Root; // It's not a revision
}
Annotation::RevType Annotation::revisionType() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
return d->revisionType;
}
const AnnotText *textann = dynamic_cast<const AnnotText *>(d->pdfAnnot);
if (textann && textann->isInReplyTo()) {
switch (textann->getState()) {
case AnnotText::stateMarked:
return Annotation::Marked;
case AnnotText::stateUnmarked:
return Annotation::Unmarked;
case AnnotText::stateAccepted:
return Annotation::Accepted;
case AnnotText::stateRejected:
return Annotation::Rejected;
case AnnotText::stateCancelled:
return Annotation::Cancelled;
case AnnotText::stateCompleted:
return Annotation::Completed;
default:
break;
}
}
return Annotation::None;
}
std::vector<std::unique_ptr<Annotation>> Annotation::revisions() const
{
Q_D(const Annotation);
if (!d->pdfAnnot) {
/* Return aliases, whose ownership goes to the caller */
std::vector<std::unique_ptr<Annotation>> res;
foreach (Annotation *rev, d->revisions)
res.push_back(std::unique_ptr<Annotation>(rev->d_ptr->makeAlias()));
return res;
}
/* If the annotation doesn't live in a object on its own (eg bug51361), it
* has no ref, therefore it can't have revisions */
if (!d->pdfAnnot->getHasRef()) {
return std::vector<std::unique_ptr<Annotation>>();
}
return AnnotationPrivate::findAnnotations(d->pdfPage, d->parentDoc, QSet<Annotation::SubType>(), d->pdfAnnot->getId());
}
std::unique_ptr<AnnotationAppearance> Annotation::annotationAppearance() const
{
Q_D(const Annotation);
return std::make_unique<AnnotationAppearance>(new AnnotationAppearancePrivate(d->pdfAnnot));
}
void Annotation::setAnnotationAppearance(const AnnotationAppearance &annotationAppearance)
{
Q_D(Annotation);
if (!d->pdfAnnot) {
d->annotationAppearance = annotationAppearance.d->appearance.copy();
return;
}
// Moving the appearance object using std::move would result
// in the object being completed moved from the AnnotationAppearancePrivate
// class. So, we'll not be able to retrieve the stamp's original AP stream
d->pdfAnnot->setNewAppearance(annotationAppearance.d->appearance.copy());
}
// END Annotation implementation
/** TextAnnotation [Annotation] */
TextAnnotationPrivate::TextAnnotationPrivate() : AnnotationPrivate(), textType(TextAnnotation::Linked), textIcon(QStringLiteral("Note")), inplaceAlign(TextAnnotation::InplaceAlignLeft), inplaceIntent(TextAnnotation::Unknown) { }
Annotation *TextAnnotationPrivate::makeAlias()
{
return new TextAnnotation(*this);
}
Annot *TextAnnotationPrivate::createNativeAnnot(::Page *destPage, DocumentData *doc)
{
// Setters are defined in the public class
TextAnnotation *q = static_cast<TextAnnotation *>(makeAlias());
// Set page and contents
pdfPage = destPage;
parentDoc = doc;
// Set pdfAnnot
PDFRectangle rect = boundaryToPdfRectangle(boundary, flags);
if (textType == TextAnnotation::Linked) {
pdfAnnot = new AnnotText { destPage->getDoc(), &rect };
} else {
const double pointSize = textFont ? textFont->pointSizeF() : AnnotFreeText::undefinedFontPtSize;
if (pointSize < 0) {
qWarning() << "TextAnnotationPrivate::createNativeAnnot: font pointSize < 0";
}
pdfAnnot = new AnnotFreeText { destPage->getDoc(), &rect };
}
// Set properties
flushBaseAnnotationProperties();
q->setTextIcon(textIcon);
q->setInplaceAlign(inplaceAlign);
q->setCalloutPoints(inplaceCallout);
q->setInplaceIntent(inplaceIntent);
delete q;
inplaceCallout.clear(); // Free up memory
setDefaultAppearanceToNative();
return pdfAnnot;
}
void TextAnnotationPrivate::setDefaultAppearanceToNative()
{
if (pdfAnnot && pdfAnnot->getType() == Annot::typeFreeText) {
AnnotFreeText *ftextann = static_cast<AnnotFreeText *>(pdfAnnot);
const double pointSize = textFont ? textFont->pointSizeF() : AnnotFreeText::undefinedFontPtSize;
if (pointSize < 0) {
qWarning() << "TextAnnotationPrivate::createNativeAnnot: font pointSize < 0";
}
std::string fontName = "Invalid_font";
if (textFont) {
Form *form = pdfPage->getDoc()->getCatalog()->getCreateForm();
if (form) {
fontName = form->findFontInDefaultResources(textFont->family().toStdString(), textFont->styleName().toStdString());
if (fontName.empty()) {
fontName = form->addFontToDefaultResources(textFont->family().toStdString(), textFont->styleName().toStdString()).fontName;
}
if (!fontName.empty()) {
form->ensureFontsForAllCharacters(pdfAnnot->getContents(), fontName);
} else {
fontName = "Invalid_font";
}
}
}
DefaultAppearance da { { objName, fontName.c_str() }, pointSize, convertQColor(textColor) };
ftextann->setDefaultAppearance(da);
}
}
std::unique_ptr<DefaultAppearance> TextAnnotationPrivate::getDefaultAppearanceFromNative() const
{
if (pdfAnnot && pdfAnnot->getType() == Annot::typeFreeText) {
AnnotFreeText *ftextann = static_cast<AnnotFreeText *>(pdfAnnot);
return ftextann->getDefaultAppearance();
} else {
return {};
}
}
TextAnnotation::TextAnnotation(TextAnnotation::TextType type) : Annotation(*new TextAnnotationPrivate())
{
setTextType(type);
}
TextAnnotation::TextAnnotation(TextAnnotationPrivate &dd) : Annotation(dd) { }
TextAnnotation::~TextAnnotation() { }
Annotation::SubType TextAnnotation::subType() const
{
return AText;
}
TextAnnotation::TextType TextAnnotation::textType() const
{
Q_D(const TextAnnotation);
if (!d->pdfAnnot) {
return d->textType;
}
return d->pdfAnnot->getType() == Annot::typeText ? TextAnnotation::Linked : TextAnnotation::InPlace;
}
void TextAnnotation::setTextType(TextAnnotation::TextType type)
{
Q_D(TextAnnotation);
if (!d->pdfAnnot) {
d->textType = type;
return;
}
// Type cannot be changed if annotation is already tied
qWarning() << "You can't change the type of a TextAnnotation that is already in a page";
}
QString TextAnnotation::textIcon() const
{
Q_D(const TextAnnotation);
if (!d->pdfAnnot) {
return d->textIcon;
}
if (d->pdfAnnot->getType() == Annot::typeText) {
const AnnotText *textann = static_cast<const AnnotText *>(d->pdfAnnot);
return QString::fromLatin1(textann->getIcon()->c_str());
}
return QString();
}
void TextAnnotation::setTextIcon(const QString &icon)
{
Q_D(TextAnnotation);
if (!d->pdfAnnot) {
d->textIcon = icon;
return;
}
if (d->pdfAnnot->getType() == Annot::typeText) {
AnnotText *textann = static_cast<AnnotText *>(d->pdfAnnot);
QByteArray encoded = icon.toLatin1();
GooString s(encoded.constData());
textann->setIcon(&s);
}
}
QFont TextAnnotation::textFont() const
{
Q_D(const TextAnnotation);
if (d->textFont) {
return *d->textFont;
}
double fontSize { AnnotFreeText::undefinedFontPtSize };
if (d->pdfAnnot->getType() == Annot::typeFreeText) {
std::unique_ptr<DefaultAppearance> da { d->getDefaultAppearanceFromNative() };
if (da && da->getFontPtSize() > 0) {
fontSize = da->getFontPtSize();
}
}
QFont font;
font.setPointSizeF(fontSize);
return font;
}
void TextAnnotation::setTextFont(const QFont &font)
{
Q_D(TextAnnotation);
if (font == d->textFont) {
return;
}
d->textFont = font;
d->setDefaultAppearanceToNative();
}
QColor TextAnnotation::textColor() const
{
Q_D(const TextAnnotation);
if (!d->pdfAnnot) {
return d->textColor;
}
if (std::unique_ptr<DefaultAppearance> da { d->getDefaultAppearanceFromNative() }) {
return convertAnnotColor(da->getFontColor());
}
return {};
}
void TextAnnotation::setTextColor(const QColor &color)
{
Q_D(TextAnnotation);
if (color == d->textColor) {
return;
}
d->textColor = color;
d->setDefaultAppearanceToNative();
}
TextAnnotation::InplaceAlignPosition TextAnnotation::inplaceAlign() const
{
Q_D(const TextAnnotation);
if (!d->pdfAnnot) {
return d->inplaceAlign;
}
if (d->pdfAnnot->getType() == Annot::typeFreeText) {
const AnnotFreeText *ftextann = static_cast<const AnnotFreeText *>(d->pdfAnnot);
switch (ftextann->getQuadding()) {
case VariableTextQuadding::leftJustified:
return InplaceAlignLeft;
case VariableTextQuadding::centered:
return InplaceAlignCenter;
case VariableTextQuadding::rightJustified:
return InplaceAlignRight;
}
}
return InplaceAlignLeft;
}
static VariableTextQuadding alignToQuadding(TextAnnotation::InplaceAlignPosition align)
{
switch (align) {
case TextAnnotation::InplaceAlignLeft:
return VariableTextQuadding::leftJustified;
case TextAnnotation::InplaceAlignCenter:
return VariableTextQuadding::centered;
case TextAnnotation::InplaceAlignRight:
return VariableTextQuadding::rightJustified;
}
return VariableTextQuadding::leftJustified;
}
void TextAnnotation::setInplaceAlign(InplaceAlignPosition align)
{
Q_D(TextAnnotation);
if (!d->pdfAnnot) {
d->inplaceAlign = align;
return;
}
if (d->pdfAnnot->getType() == Annot::typeFreeText) {
AnnotFreeText *ftextann = static_cast<AnnotFreeText *>(d->pdfAnnot);
ftextann->setQuadding(alignToQuadding(align));
}
}
QPointF TextAnnotation::calloutPoint(int id) const
{
const QVector<QPointF> points = calloutPoints();
if (id < 0 || id >= points.size()) {
return QPointF();
} else {
return points[id];
}
}
QVector<QPointF> TextAnnotation::calloutPoints() const
{
Q_D(const TextAnnotation);
if (!d->pdfAnnot) {
return d->inplaceCallout;
}
if (d->pdfAnnot->getType() == Annot::typeText) {
return QVector<QPointF>();
}
const AnnotFreeText *ftextann = static_cast<const AnnotFreeText *>(d->pdfAnnot);
const AnnotCalloutLine *callout = ftextann->getCalloutLine();
if (!callout) {
return QVector<QPointF>();
}
double MTX[6];
d->fillTransformationMTX(MTX);
const AnnotCalloutMultiLine *callout_v6 = dynamic_cast<const AnnotCalloutMultiLine *>(callout);
QVector<QPointF> res(callout_v6 ? 3 : 2);
XPDFReader::transform(MTX, callout->getX1(), callout->getY1(), res[0]);
XPDFReader::transform(MTX, callout->getX2(), callout->getY2(), res[1]);
if (callout_v6) {
XPDFReader::transform(MTX, callout_v6->getX3(), callout_v6->getY3(), res[2]);
}
return res;
}
void TextAnnotation::setCalloutPoints(const QVector<QPointF> &points)
{
Q_D(TextAnnotation);
if (!d->pdfAnnot) {
d->inplaceCallout = points;
return;
}
if (d->pdfAnnot->getType() != Annot::typeFreeText) {
return;
}
AnnotFreeText *ftextann = static_cast<AnnotFreeText *>(d->pdfAnnot);
const int count = points.size();
if (count == 0) {
ftextann->setCalloutLine(nullptr);
return;
}
if (count != 2 && count != 3) {
error(errSyntaxError, -1, "Expected zero, two or three points for callout");
return;
}
AnnotCalloutLine *callout;
double x1, y1, x2, y2;
double MTX[6];
d->fillTransformationMTX(MTX);
XPDFReader::invTransform(MTX, points[0], x1, y1);
XPDFReader::invTransform(MTX, points[1], x2, y2);
if (count == 3) {
double x3, y3;
XPDFReader::invTransform(MTX, points[2], x3, y3);
callout = new AnnotCalloutMultiLine(x1, y1, x2, y2, x3, y3);
} else {
callout = new AnnotCalloutLine(x1, y1, x2, y2);
}
ftextann->setCalloutLine(callout);
delete callout;
}
TextAnnotation::InplaceIntent TextAnnotation::inplaceIntent() const
{
Q_D(const TextAnnotation);
if (!d->pdfAnnot) {
return d->inplaceIntent;
}
if (d->pdfAnnot->getType() == Annot::typeFreeText) {
const AnnotFreeText *ftextann = static_cast<const AnnotFreeText *>(d->pdfAnnot);
return (TextAnnotation::InplaceIntent)ftextann->getIntent();
}
return TextAnnotation::Unknown;
}
void TextAnnotation::setInplaceIntent(TextAnnotation::InplaceIntent intent)
{
Q_D(TextAnnotation);
if (!d->pdfAnnot) {
d->inplaceIntent = intent;
return;
}
if (d->pdfAnnot->getType() == Annot::typeFreeText) {
AnnotFreeText *ftextann = static_cast<AnnotFreeText *>(d->pdfAnnot);
ftextann->setIntent((AnnotFreeText::AnnotFreeTextIntent)intent);
}
}
/** LineAnnotation [Annotation] */
class LineAnnotationPrivate : public AnnotationPrivate
{
public:
LineAnnotationPrivate();
Annotation *makeAlias() override;
Annot *createNativeAnnot(::Page *destPage, DocumentData *doc) override;
// data fields (note uses border for rendering style)
QVector<QPointF> linePoints;
LineAnnotation::TermStyle lineStartStyle;
LineAnnotation::TermStyle lineEndStyle;
bool lineClosed : 1; // (if true draw close shape)
bool lineShowCaption : 1;
LineAnnotation::LineType lineType;
QColor lineInnerColor;
double lineLeadingFwdPt;
double lineLeadingBackPt;
LineAnnotation::LineIntent lineIntent;
};
LineAnnotationPrivate::LineAnnotationPrivate()
: AnnotationPrivate(), lineStartStyle(LineAnnotation::None), lineEndStyle(LineAnnotation::None), lineClosed(false), lineShowCaption(false), lineLeadingFwdPt(0), lineLeadingBackPt(0), lineIntent(LineAnnotation::Unknown)
{
}
Annotation *LineAnnotationPrivate::makeAlias()
{
return new LineAnnotation(*this);
}
Annot *LineAnnotationPrivate::createNativeAnnot(::Page *destPage, DocumentData *doc)
{
// Setters are defined in the public class
LineAnnotation *q = static_cast<LineAnnotation *>(makeAlias());
// Set page and document
pdfPage = destPage;
parentDoc = doc;
// Set pdfAnnot
PDFRectangle rect = boundaryToPdfRectangle(boundary, flags);
if (lineType == LineAnnotation::StraightLine) {
pdfAnnot = new AnnotLine(doc->doc, &rect);
} else {
pdfAnnot = new AnnotPolygon(doc->doc, &rect, lineClosed ? Annot::typePolygon : Annot::typePolyLine);
}
// Set properties
flushBaseAnnotationProperties();
q->setLinePoints(linePoints);
q->setLineStartStyle(lineStartStyle);
q->setLineEndStyle(lineEndStyle);
q->setLineInnerColor(lineInnerColor);
q->setLineLeadingForwardPoint(lineLeadingFwdPt);
q->setLineLeadingBackPoint(lineLeadingBackPt);
q->setLineShowCaption(lineShowCaption);
q->setLineIntent(lineIntent);
delete q;
linePoints.clear(); // Free up memory
return pdfAnnot;
}
LineAnnotation::LineAnnotation(LineAnnotation::LineType type) : Annotation(*new LineAnnotationPrivate())
{
setLineType(type);
}
LineAnnotation::LineAnnotation(LineAnnotationPrivate &dd) : Annotation(dd) { }
LineAnnotation::~LineAnnotation() { }
Annotation::SubType LineAnnotation::subType() const
{
return ALine;
}
LineAnnotation::LineType LineAnnotation::lineType() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineType;
}
return (d->pdfAnnot->getType() == Annot::typeLine) ? LineAnnotation::StraightLine : LineAnnotation::Polyline;
}
void LineAnnotation::setLineType(LineAnnotation::LineType type)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineType = type;
return;
}
// Type cannot be changed if annotation is already tied
qWarning() << "You can't change the type of a LineAnnotation that is already in a page";
}
QVector<QPointF> LineAnnotation::linePoints() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->linePoints;
}
double MTX[6];
d->fillTransformationMTX(MTX);
QVector<QPointF> res;
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
QPointF p;
XPDFReader::transform(MTX, lineann->getX1(), lineann->getY1(), p);
res.append(p);
XPDFReader::transform(MTX, lineann->getX2(), lineann->getY2(), p);
res.append(p);
} else {
const AnnotPolygon *polyann = static_cast<const AnnotPolygon *>(d->pdfAnnot);
const AnnotPath *vertices = polyann->getVertices();
for (int i = 0; i < vertices->getCoordsLength(); ++i) {
QPointF p;
XPDFReader::transform(MTX, vertices->getX(i), vertices->getY(i), p);
res.append(p);
}
}
return res;
}
void LineAnnotation::setLinePoints(const QVector<QPointF> &points)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->linePoints = points;
return;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
if (points.size() != 2) {
error(errSyntaxError, -1, "Expected two points for a straight line");
return;
}
double x1, y1, x2, y2;
double MTX[6];
d->fillTransformationMTX(MTX);
XPDFReader::invTransform(MTX, points.first(), x1, y1);
XPDFReader::invTransform(MTX, points.last(), x2, y2);
lineann->setVertices(x1, y1, x2, y2);
} else {
AnnotPolygon *polyann = static_cast<AnnotPolygon *>(d->pdfAnnot);
AnnotPath *p = d->toAnnotPath(points);
polyann->setVertices(p);
delete p;
}
}
LineAnnotation::TermStyle LineAnnotation::lineStartStyle() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineStartStyle;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
return (LineAnnotation::TermStyle)lineann->getStartStyle();
} else {
const AnnotPolygon *polyann = static_cast<const AnnotPolygon *>(d->pdfAnnot);
return (LineAnnotation::TermStyle)polyann->getStartStyle();
}
}
void LineAnnotation::setLineStartStyle(LineAnnotation::TermStyle style)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineStartStyle = style;
return;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setStartEndStyle((AnnotLineEndingStyle)style, lineann->getEndStyle());
} else {
AnnotPolygon *polyann = static_cast<AnnotPolygon *>(d->pdfAnnot);
polyann->setStartEndStyle((AnnotLineEndingStyle)style, polyann->getEndStyle());
}
}
LineAnnotation::TermStyle LineAnnotation::lineEndStyle() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineEndStyle;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
return (LineAnnotation::TermStyle)lineann->getEndStyle();
} else {
const AnnotPolygon *polyann = static_cast<const AnnotPolygon *>(d->pdfAnnot);
return (LineAnnotation::TermStyle)polyann->getEndStyle();
}
}
void LineAnnotation::setLineEndStyle(LineAnnotation::TermStyle style)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineEndStyle = style;
return;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setStartEndStyle(lineann->getStartStyle(), (AnnotLineEndingStyle)style);
} else {
AnnotPolygon *polyann = static_cast<AnnotPolygon *>(d->pdfAnnot);
polyann->setStartEndStyle(polyann->getStartStyle(), (AnnotLineEndingStyle)style);
}
}
bool LineAnnotation::isLineClosed() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineClosed;
}
return d->pdfAnnot->getType() == Annot::typePolygon;
}
void LineAnnotation::setLineClosed(bool closed)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineClosed = closed;
return;
}
if (d->pdfAnnot->getType() != Annot::typeLine) {
AnnotPolygon *polyann = static_cast<AnnotPolygon *>(d->pdfAnnot);
// Set new subtype and switch intent if necessary
if (closed) {
polyann->setType(Annot::typePolygon);
if (polyann->getIntent() == AnnotPolygon::polylineDimension) {
polyann->setIntent(AnnotPolygon::polygonDimension);
}
} else {
polyann->setType(Annot::typePolyLine);
if (polyann->getIntent() == AnnotPolygon::polygonDimension) {
polyann->setIntent(AnnotPolygon::polylineDimension);
}
}
}
}
QColor LineAnnotation::lineInnerColor() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineInnerColor;
}
AnnotColor *c;
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
c = lineann->getInteriorColor();
} else {
const AnnotPolygon *polyann = static_cast<const AnnotPolygon *>(d->pdfAnnot);
c = polyann->getInteriorColor();
}
return convertAnnotColor(c);
}
void LineAnnotation::setLineInnerColor(const QColor &color)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineInnerColor = color;
return;
}
auto c = convertQColor(color);
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setInteriorColor(std::move(c));
} else {
AnnotPolygon *polyann = static_cast<AnnotPolygon *>(d->pdfAnnot);
polyann->setInteriorColor(std::move(c));
}
}
double LineAnnotation::lineLeadingForwardPoint() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineLeadingFwdPt;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
return lineann->getLeaderLineLength();
}
return 0;
}
void LineAnnotation::setLineLeadingForwardPoint(double point)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineLeadingFwdPt = point;
return;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setLeaderLineLength(point);
}
}
double LineAnnotation::lineLeadingBackPoint() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineLeadingBackPt;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
return lineann->getLeaderLineExtension();
}
return 0;
}
void LineAnnotation::setLineLeadingBackPoint(double point)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineLeadingBackPt = point;
return;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setLeaderLineExtension(point);
}
}
bool LineAnnotation::lineShowCaption() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineShowCaption;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
return lineann->getCaption();
}
return false;
}
void LineAnnotation::setLineShowCaption(bool show)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineShowCaption = show;
return;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setCaption(show);
}
}
LineAnnotation::LineIntent LineAnnotation::lineIntent() const
{
Q_D(const LineAnnotation);
if (!d->pdfAnnot) {
return d->lineIntent;
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
const AnnotLine *lineann = static_cast<const AnnotLine *>(d->pdfAnnot);
return (LineAnnotation::LineIntent)(lineann->getIntent() + 1);
} else {
const AnnotPolygon *polyann = static_cast<const AnnotPolygon *>(d->pdfAnnot);
if (polyann->getIntent() == AnnotPolygon::polygonCloud) {
return LineAnnotation::PolygonCloud;
} else { // AnnotPolygon::polylineDimension, AnnotPolygon::polygonDimension
return LineAnnotation::Dimension;
}
}
}
void LineAnnotation::setLineIntent(LineAnnotation::LineIntent intent)
{
Q_D(LineAnnotation);
if (!d->pdfAnnot) {
d->lineIntent = intent;
return;
}
if (intent == LineAnnotation::Unknown) {
return; // Do not set (actually, it should clear the property)
}
if (d->pdfAnnot->getType() == Annot::typeLine) {
AnnotLine *lineann = static_cast<AnnotLine *>(d->pdfAnnot);
lineann->setIntent((AnnotLine::AnnotLineIntent)(intent - 1));
} else {
AnnotPolygon *polyann = static_cast<AnnotPolygon *>(d->pdfAnnot);
if (intent == LineAnnotation::PolygonCloud) {
polyann->setIntent(AnnotPolygon::polygonCloud);
} else // LineAnnotation::Dimension
{
if (d->pdfAnnot->getType() == Annot::typePolygon) {
polyann->setIntent(AnnotPolygon::polygonDimension);
} else { // Annot::typePolyLine
polyann->setIntent(AnnotPolygon::polylineDimension);
}
}
}
}
/** GeomAnnotation [Annotation] */
class GeomAnnotationPrivate : public AnnotationPrivate
{
public:
GeomAnnotationPrivate();
Annotation *makeAlias() override;
Annot *createNativeAnnot(::Page *destPage, DocumentData *doc) override;
// data fields (note uses border for rendering style)
GeomAnnotation::GeomType geomType;
QColor geomInnerColor;
};
GeomAnnotationPrivate::GeomAnnotationPrivate() : AnnotationPrivate(), geomType(GeomAnnotation::InscribedSquare) { }
Annotation *GeomAnnotationPrivate::makeAlias()
{
return new GeomAnnotation(*this);
}
Annot *GeomAnnotationPrivate::createNativeAnnot(::Page *destPage, DocumentData *doc)
{
// Setters are defined in the public class
GeomAnnotation *q = static_cast<GeomAnnotation *>(makeAlias());
// Set page and document
pdfPage = destPage;
parentDoc = doc;
Annot::AnnotSubtype type;
if (geomType == GeomAnnotation::InscribedSquare) {
type = Annot::typeSquare;
} else { // GeomAnnotation::InscribedCircle
type = Annot::typeCircle;
}
// Set pdfAnnot
PDFRectangle rect = boundaryToPdfRectangle(boundary, flags);
pdfAnnot = new AnnotGeometry(destPage->getDoc(), &rect, type);
// Set properties
flushBaseAnnotationProperties();
q->setGeomInnerColor(geomInnerColor);
delete q;
return pdfAnnot;
}
GeomAnnotation::GeomAnnotation() : Annotation(*new GeomAnnotationPrivate()) { }
GeomAnnotation::GeomAnnotation(GeomAnnotationPrivate &dd) : Annotation(dd) { }
GeomAnnotation::~GeomAnnotation() { }
Annotation::SubType GeomAnnotation::subType() const
{
return AGeom;
}
GeomAnnotation::GeomType GeomAnnotation::geomType() const
{
Q_D(const GeomAnnotation);
if (!d->pdfAnnot) {
return d->geomType;
}
if (d->pdfAnnot->getType() == Annot::typeSquare) {
return GeomAnnotation::InscribedSquare;
} else { // Annot::typeCircle
return GeomAnnotation::InscribedCircle;
}
}
void GeomAnnotation::setGeomType(GeomAnnotation::GeomType type)
{
Q_D(GeomAnnotation);
if (!d->pdfAnnot) {
d->geomType = type;
return;
}
AnnotGeometry *geomann = static_cast<AnnotGeometry *>(d->pdfAnnot);
if (type == GeomAnnotation::InscribedSquare) {
geomann->setType(Annot::typeSquare);
} else { // GeomAnnotation::InscribedCircle
geomann->setType(Annot::typeCircle);
}
}
QColor GeomAnnotation::geomInnerColor() const
{
Q_D(const GeomAnnotation);
if (!d->pdfAnnot) {
return d->geomInnerColor;
}
const AnnotGeometry *geomann = static_cast<const AnnotGeometry *>(d->pdfAnnot);
return convertAnnotColor(geomann->getInteriorColor());
}
void GeomAnnotation::setGeomInnerColor(const QColor &color)
{
Q_D(GeomAnnotation);
if (!d->pdfAnnot) {
d->geomInnerColor = color;
return;
}
AnnotGeometry *geomann = static_cast<AnnotGeometry *>(d->pdfAnnot);
geomann->setInteriorColor(convertQColor(color));
}
/** HighlightAnnotation [Annotation] */
class HighlightAnnotationPrivate : public AnnotationPrivate
{
public:
HighlightAnnotationPrivate();
Annotation *makeAlias() override;
Annot *createNativeAnnot(::Page *destPage, DocumentData *doc) override;
// data fields
HighlightAnnotation::HighlightType highlightType;
QList<HighlightAnnotation::Quad> highlightQuads; // not empty
// helpers
static Annot::AnnotSubtype toAnnotSubType(HighlightAnnotation::HighlightType type);
QList<HighlightAnnotation::Quad> fromQuadrilaterals(AnnotQuadrilaterals *quads) const;
AnnotQuadrilaterals *toQuadrilaterals(const QList<HighlightAnnotation::Quad> &quads) const;
};
HighlightAnnotationPrivate::HighlightAnnotationPrivate() : AnnotationPrivate(), highlightType(HighlightAnnotation::Highlight) { }
Annotation *HighlightAnnotationPrivate::makeAlias()
{
return new HighlightAnnotation(*this);
}
Annot::AnnotSubtype HighlightAnnotationPrivate::toAnnotSubType(HighlightAnnotation::HighlightType type)
{
switch (type) {
default: // HighlightAnnotation::Highlight:
return Annot::typeHighlight;
case HighlightAnnotation::Underline:
return Annot::typeUnderline;
case HighlightAnnotation::Squiggly:
return Annot::typeSquiggly;
case HighlightAnnotation::StrikeOut:
return Annot::typeStrikeOut;
}
}
QList<HighlightAnnotation::Quad> HighlightAnnotationPrivate::fromQuadrilaterals(AnnotQuadrilaterals *hlquads) const
{
QList<HighlightAnnotation::Quad> quads;
if (!hlquads || !hlquads->getQuadrilateralsLength()) {
return quads;
}
const int quadsCount = hlquads->getQuadrilateralsLength();
double MTX[6];
fillTransformationMTX(MTX);
quads.reserve(quadsCount);
for (int q = 0; q < quadsCount; ++q) {
HighlightAnnotation::Quad quad;
XPDFReader::transform(MTX, hlquads->getX1(q), hlquads->getY1(q), quad.points[0]);
XPDFReader::transform(MTX, hlquads->getX2(q), hlquads->getY2(q), quad.points[1]);
XPDFReader::transform(MTX, hlquads->getX3(q), hlquads->getY3(q), quad.points[2]);
XPDFReader::transform(MTX, hlquads->getX4(q), hlquads->getY4(q), quad.points[3]);
// ### PDF1.6 specs says that point are in ccw order, but in fact
// points 3 and 4 are swapped in every PDF around!
QPointF tmpPoint = quad.points[2];
quad.points[2] = quad.points[3];
quad.points[3] = tmpPoint;
// initialize other properties and append quad
quad.capStart = true; // unlinked quads are always capped
quad.capEnd = true; // unlinked quads are always capped
quad.feather = 0.1; // default feather
quads.append(quad);
}
return quads;
}
AnnotQuadrilaterals *HighlightAnnotationPrivate::toQuadrilaterals(const QList<HighlightAnnotation::Quad> &quads) const
{
const int count = quads.size();
auto ac = std::make_unique<AnnotQuadrilaterals::AnnotQuadrilateral[]>(count);
double MTX[6];
fillTransformationMTX(MTX);
int pos = 0;
foreach (const HighlightAnnotation::Quad &q, quads) {
double x1, y1, x2, y2, x3, y3, x4, y4;
XPDFReader::invTransform(MTX, q.points[0], x1, y1);
XPDFReader::invTransform(MTX, q.points[1], x2, y2);
// Swap points 3 and 4 (see HighlightAnnotationPrivate::fromQuadrilaterals)
XPDFReader::invTransform(MTX, q.points[3], x3, y3);
XPDFReader::invTransform(MTX, q.points[2], x4, y4);
ac[pos++] = AnnotQuadrilaterals::AnnotQuadrilateral(x1, y1, x2, y2, x3, y3, x4, y4);
}
return new AnnotQuadrilaterals(std::move(ac), count);
}
Annot *HighlightAnnotationPrivate::createNativeAnnot(::Page *destPage, DocumentData *doc)
{
// Setters are defined in the public class
HighlightAnnotation *q = static_cast<HighlightAnnotation *>(makeAlias());
// Set page and document
pdfPage = destPage;
parentDoc = doc;
// Set pdfAnnot
PDFRectangle rect = boundaryToPdfRectangle(boundary, flags);
pdfAnnot = new AnnotTextMarkup(destPage->getDoc(), &rect, toAnnotSubType(highlightType));
// Set properties
flushBaseAnnotationProperties();
q->setHighlightQuads(highlightQuads);
highlightQuads.clear(); // Free up memory
delete q;
return pdfAnnot;
}
HighlightAnnotation::HighlightAnnotation() : Annotation(*new HighlightAnnotationPrivate()) { }
HighlightAnnotation::HighlightAnnotation(HighlightAnnotationPrivate &dd) : Annotation(dd) { }
HighlightAnnotation::~HighlightAnnotation() { }
Annotation::SubType HighlightAnnotation::subType() const
{
return AHighlight;
}
HighlightAnnotation::HighlightType HighlightAnnotation::highlightType() const
{
Q_D(const HighlightAnnotation);
if (!d->pdfAnnot) {
return d->highlightType;
}
Annot::AnnotSubtype subType = d->pdfAnnot->getType();
if (subType == Annot::typeHighlight) {
return HighlightAnnotation::Highlight;
} else if (subType == Annot::typeUnderline) {
return HighlightAnnotation::Underline;
} else if (subType == Annot::typeSquiggly) {
return HighlightAnnotation::Squiggly;
} else { // Annot::typeStrikeOut
return HighlightAnnotation::StrikeOut;
}
}
void HighlightAnnotation::setHighlightType(HighlightAnnotation::HighlightType type)
{
Q_D(HighlightAnnotation);
if (!d->pdfAnnot) {
d->highlightType = type;
return;
}
AnnotTextMarkup *hlann = static_cast<AnnotTextMarkup *>(d->pdfAnnot);
hlann->setType(HighlightAnnotationPrivate::toAnnotSubType(type));
}
QList<HighlightAnnotation::Quad> HighlightAnnotation::highlightQuads() const
{
Q_D(const HighlightAnnotation);
if (!d->pdfAnnot) {
return d->highlightQuads;
}
const AnnotTextMarkup *hlann = static_cast<AnnotTextMarkup *>(d->pdfAnnot);
return d->fromQuadrilaterals(hlann->getQuadrilaterals());
}
void HighlightAnnotation::setHighlightQuads(const QList<HighlightAnnotation::Quad> &quads)
{
Q_D(HighlightAnnotation);
if (!d->pdfAnnot) {
d->highlightQuads = quads;
return;
}
AnnotTextMarkup *hlann = static_cast<AnnotTextMarkup *>(d->pdfAnnot);
AnnotQuadrilaterals *quadrilaterals = d->toQuadrilaterals(quads);
hlann->setQuadrilaterals(quadrilaterals);
delete quadrilaterals;
}
/** StampAnnotation [Annotation] */
class StampAnnotationPrivate : public AnnotationPrivate
{
public:
StampAnnotationPrivate();
Annotation *makeAlias() override;
Annot *createNativeAnnot(::Page *destPage, DocumentData *doc) override;
AnnotStampImageHelper *convertQImageToAnnotStampImageHelper(const QImage &qimg);
// data fields
QString stampIconName;
QImage stampCustomImage;
};
StampAnnotationPrivate::StampAnnotationPrivate() : AnnotationPrivate(), stampIconName(QStringLiteral("Draft")) { }
Annotation *StampAnnotationPrivate::makeAlias()
{
return new StampAnnotation(*this);
}
Annot *StampAnnotationPrivate::createNativeAnnot(::Page *destPage, DocumentData *doc)
{
StampAnnotation *q = static_cast<StampAnnotation *>(makeAlias());
// Set page and document
pdfPage = destPage;
parentDoc = doc;
// Set pdfAnnot
PDFRectangle rect = boundaryToPdfRectangle(boundary, flags);
pdfAnnot = new AnnotStamp(destPage->getDoc(), &rect);
// Set properties
flushBaseAnnotationProperties();
q->setStampIconName(stampIconName);
q->setStampCustomImage(stampCustomImage);
delete q;
stampIconName.clear(); // Free up memory
return pdfAnnot;
}
AnnotStampImageHelper *StampAnnotationPrivate::convertQImageToAnnotStampImageHelper(const QImage &qimg)
{
QImage convertedQImage = qimg;
QByteArray data;
QByteArray sMaskData;
const int width = convertedQImage.width();
const int height = convertedQImage.height();
int bitsPerComponent = 1;
ColorSpace colorSpace = ColorSpace::DeviceGray;
switch (convertedQImage.format()) {
case QImage::Format_MonoLSB:
if (!convertedQImage.allGray()) {
convertedQImage = convertedQImage.convertToFormat(QImage::Format_RGB888);
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
} else {
convertedQImage = convertedQImage.convertToFormat(QImage::Format_Mono);
}
break;
case QImage::Format_Mono:
if (!convertedQImage.allGray()) {
convertedQImage = convertedQImage.convertToFormat(QImage::Format_RGB888);
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
}
break;
case QImage::Format_RGB32:
case QImage::Format_ARGB32_Premultiplied:
case QImage::Format_ARGB8565_Premultiplied:
case QImage::Format_ARGB6666_Premultiplied:
case QImage::Format_ARGB8555_Premultiplied:
case QImage::Format_ARGB4444_Premultiplied:
case QImage::Format_Alpha8:
convertedQImage = convertedQImage.convertToFormat(QImage::Format_ARGB32);
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
break;
case QImage::Format_RGBA8888:
case QImage::Format_RGBA8888_Premultiplied:
case QImage::Format_RGBX8888:
case QImage::Format_ARGB32:
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
break;
case QImage::Format_Grayscale8:
bitsPerComponent = 8;
break;
case QImage::Format_Grayscale16:
convertedQImage = convertedQImage.convertToFormat(QImage::Format_Grayscale8);
colorSpace = ColorSpace::DeviceGray;
bitsPerComponent = 8;
break;
case QImage::Format_RGB16:
case QImage::Format_RGB666:
case QImage::Format_RGB555:
case QImage::Format_RGB444:
convertedQImage = convertedQImage.convertToFormat(QImage::Format_RGB888);
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
break;
case QImage::Format_RGB888:
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
break;
default:
convertedQImage = convertedQImage.convertToFormat(QImage::Format_ARGB32);
colorSpace = ColorSpace::DeviceRGB;
bitsPerComponent = 8;
break;
}
getRawDataFromQImage(convertedQImage, convertedQImage.depth(), &data, &sMaskData);
AnnotStampImageHelper *annotImg;
if (sMaskData.size() > 0) {
AnnotStampImageHelper sMask(parentDoc->doc, width, height, ColorSpace::DeviceGray, 8, sMaskData.data(), sMaskData.size());
annotImg = new AnnotStampImageHelper(parentDoc->doc, width, height, colorSpace, bitsPerComponent, data.data(), data.size(), sMask.getRef());
} else {
annotImg = new AnnotStampImageHelper(parentDoc->doc, width, height, colorSpace, bitsPerComponent, data.data(), data.size());
}
return annotImg;
}
StampAnnotation::StampAnnotation() : Annotation(*new StampAnnotationPrivate()) { }
StampAnnotation::StampAnnotation(StampAnnotationPrivate &dd) : Annotation(dd) { }
StampAnnotation::~StampAnnotation() { }
Annotation::SubType StampAnnotation::subType() const
{
return AStamp;
}
QString StampAnnotation::stampIconName() const
{
Q_D(const StampAnnotation);
if (!d->pdfAnnot) {
return d->stampIconName;
}
const AnnotStamp *stampann = static_cast<const AnnotStamp *>(d->pdfAnnot);
return QString::fromLatin1(stampann->getIcon()->c_str());
}
void StampAnnotation::setStampIconName(const QString &name)
{
Q_D(StampAnnotation);
if (!d->pdfAnnot) {
d->stampIconName = name;
return;
}
AnnotStamp *stampann =<