mirror of
https://invent.kde.org/graphics/okular
synced 2024-07-05 00:58:46 +00:00
3255 lines
89 KiB
C++
3255 lines
89 KiB
C++
/*
|
|
SPDX-FileCopyrightText: 2005 Enrico Ros <eros.kde@email.it>
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#include "annotations.h"
|
|
#include "annotations_p.h"
|
|
|
|
// qt/kde includes
|
|
#include <QApplication>
|
|
#include <QColor>
|
|
#include <QFile>
|
|
#include <QIcon>
|
|
#include <QPainter>
|
|
#include <QStandardPaths>
|
|
#include <QSvgRenderer>
|
|
|
|
// DBL_MAX
|
|
#include <float.h>
|
|
|
|
// local includes
|
|
#include "action.h"
|
|
#include "document.h"
|
|
#include "document_p.h"
|
|
#include "movie.h"
|
|
#include "page_p.h"
|
|
#include "sound.h"
|
|
|
|
using namespace Okular;
|
|
|
|
/**
|
|
* True, if point @p c lies to the left of the vector from @p a to @p b
|
|
* @internal
|
|
*/
|
|
static bool isLeftOfVector(const NormalizedPoint &a, const NormalizedPoint &b, const NormalizedPoint &c)
|
|
{
|
|
// cross product
|
|
return ((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x)) > 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Calculates distance of the given point @p x @p y @p xScale @p yScale to the @p path
|
|
*
|
|
* Does piecewise comparison and selects the distance to the closest segment
|
|
*/
|
|
static double distanceSqr(double x, double y, double xScale, double yScale, const QList<NormalizedPoint> &path)
|
|
{
|
|
double distance = DBL_MAX;
|
|
QList<NormalizedPoint>::const_iterator i = path.constBegin();
|
|
NormalizedPoint lastPoint = *i;
|
|
|
|
for (++i; i != path.constEnd(); ++i) {
|
|
double thisDistance = NormalizedPoint::distanceSqr(x, y, xScale, yScale, lastPoint, (*i));
|
|
|
|
if (thisDistance < distance) {
|
|
distance = thisDistance;
|
|
}
|
|
|
|
lastPoint = *i;
|
|
}
|
|
return distance;
|
|
}
|
|
|
|
/**
|
|
* Given the squared @p distance from the idealized 0-width line and a pen width @p penWidth,
|
|
* (not squared!), returns the final distance
|
|
*
|
|
* @warning The returned distance is not exact:
|
|
* We calculate an (exact) squared distance to the ideal (centered) line, and then subtract
|
|
* the squared width of the pen:
|
|
* a^2 - b^2 where a = "distance from idealized 0-width line" b = "pen width"
|
|
* For an exact result, we would want to calculate "(a - b)^2" but that would require
|
|
* a square root operation because we only know the squared distance a^2.
|
|
*
|
|
* However, the approximation is feasible, because:
|
|
* error = (a-b)^2 - (a^2 - b^2) = -2ab + 2b^2 = 2b(b - a)
|
|
* Therefore:
|
|
* lim_{a->b} a^2 - b^2 - a^2 + 2ab - b^2 --> 0
|
|
*
|
|
* In other words, this approximation will estimate the distance to be slightly more than it actually is
|
|
* for as long as we are far "outside" the line, becoming more accurate the closer we get to the line
|
|
* boundary. Trivially, it also fulfils (a1 < a2) => ((a1^2 - b^2) < (a2^2 - b^2)) making it monotonic.
|
|
* "Inside" of the drawn line, the distance is 0 anyway.
|
|
*/
|
|
static double strokeDistance(double distance, double penWidth)
|
|
{
|
|
return fmax(distance - pow(penWidth, 2), 0);
|
|
}
|
|
|
|
// BEGIN AnnotationUtils implementation
|
|
Annotation *AnnotationUtils::createAnnotation(const QDomElement &annElement)
|
|
{
|
|
// safety check on annotation element
|
|
if (!annElement.hasAttribute(QStringLiteral("type"))) {
|
|
return nullptr;
|
|
}
|
|
|
|
// build annotation of given type
|
|
Annotation *annotation = nullptr;
|
|
int typeNumber = annElement.attribute(QStringLiteral("type")).toInt();
|
|
switch (typeNumber) {
|
|
case Annotation::AText:
|
|
annotation = new TextAnnotation(annElement);
|
|
break;
|
|
case Annotation::ALine:
|
|
annotation = new LineAnnotation(annElement);
|
|
break;
|
|
case Annotation::AGeom:
|
|
annotation = new GeomAnnotation(annElement);
|
|
break;
|
|
case Annotation::AHighlight:
|
|
annotation = new HighlightAnnotation(annElement);
|
|
break;
|
|
case Annotation::AStamp:
|
|
annotation = new StampAnnotation(annElement);
|
|
break;
|
|
case Annotation::AInk:
|
|
annotation = new InkAnnotation(annElement);
|
|
break;
|
|
case Annotation::ACaret:
|
|
annotation = new CaretAnnotation(annElement);
|
|
break;
|
|
}
|
|
|
|
// return created annotation
|
|
return annotation;
|
|
}
|
|
|
|
void AnnotationUtils::storeAnnotation(const Annotation *ann, QDomElement &annElement, QDomDocument &document)
|
|
{
|
|
// save annotation's type as element's attribute
|
|
annElement.setAttribute(QStringLiteral("type"), (uint)ann->subType());
|
|
|
|
// append all annotation data as children of this node
|
|
ann->store(annElement, document);
|
|
}
|
|
|
|
QDomElement AnnotationUtils::findChildElement(const QDomNode &parentNode, const QString &name)
|
|
{
|
|
// loop through the whole children and return a 'name' named element
|
|
QDomNode subNode = parentNode.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement element = subNode.toElement();
|
|
if (element.tagName() == name) {
|
|
return element;
|
|
}
|
|
subNode = subNode.nextSibling();
|
|
}
|
|
// if the name can't be found, return a dummy null element
|
|
return QDomElement();
|
|
}
|
|
|
|
QRect AnnotationUtils::annotationGeometry(const Annotation *annotation, double scaleX, double scaleY)
|
|
{
|
|
const QRect rect = annotation->transformedBoundingRectangle().geometry((int)scaleX, (int)scaleY);
|
|
if (annotation->subType() == Annotation::AText && (static_cast<const TextAnnotation *>(annotation)->textType() == TextAnnotation::Linked)) {
|
|
// To be honest i have no clue of why the 24,24 is here, maybe to make sure it's not too small?
|
|
// But why only for linked text?
|
|
const QRect rect24 = QRect((int)(annotation->transformedBoundingRectangle().left * scaleX), (int)(annotation->transformedBoundingRectangle().top * scaleY), 24, 24);
|
|
return rect24.united(rect);
|
|
}
|
|
|
|
return rect;
|
|
}
|
|
|
|
QPixmap AnnotationUtils::loadStamp(const QString &nameOrPath, int size, bool keepAspectRatio)
|
|
{
|
|
const QString name = nameOrPath.toLower();
|
|
|
|
static std::unique_ptr<QSvgRenderer> svgStampFile;
|
|
if (!svgStampFile.get()) {
|
|
const QString stampFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("okular/pics/stamps.svg"));
|
|
if (!stampFile.isEmpty()) {
|
|
svgStampFile = std::make_unique<QSvgRenderer>(stampFile);
|
|
if (!svgStampFile->isValid()) {
|
|
svgStampFile.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
QSvgRenderer *r = svgStampFile.get();
|
|
if (r && r->isValid() && r->elementExists(name)) {
|
|
const QSize stampSize = r->boundsOnElement(name).size().toSize();
|
|
const QSize pixmapSize = stampSize.scaled(size, size, keepAspectRatio ? Qt::KeepAspectRatioByExpanding : Qt::IgnoreAspectRatio);
|
|
QPixmap pixmap(pixmapSize);
|
|
pixmap.fill(Qt::transparent);
|
|
QPainter p(&pixmap);
|
|
r->render(&p, name);
|
|
p.end();
|
|
return pixmap;
|
|
}
|
|
|
|
// _name is a path (do this before loading as icon name to avoid some rare weirdness )
|
|
// Check that it exists up front. While pixmap.load() fails, if it is
|
|
// actually an icon from theme, the loader will try all supported
|
|
// extensions in current workdir before failing
|
|
if (QFile::exists(nameOrPath)) {
|
|
QPixmap pixmap;
|
|
pixmap.load(nameOrPath);
|
|
if (!pixmap.isNull()) {
|
|
pixmap = pixmap.scaled(size, size, keepAspectRatio ? Qt::KeepAspectRatioByExpanding : Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
|
|
return pixmap;
|
|
}
|
|
}
|
|
|
|
// _name is an icon name
|
|
return QIcon::fromTheme(name).pixmap(size);
|
|
}
|
|
// END AnnotationUtils implementation
|
|
|
|
AnnotationProxy::AnnotationProxy()
|
|
{
|
|
}
|
|
|
|
AnnotationProxy::~AnnotationProxy()
|
|
{
|
|
}
|
|
|
|
// BEGIN Annotation implementation
|
|
|
|
class Annotation::Style::Private
|
|
{
|
|
public:
|
|
Private()
|
|
: m_opacity(1.0)
|
|
, m_width(1.0)
|
|
, m_style(Solid)
|
|
, m_xCorners(0.0)
|
|
, m_yCorners(0.0)
|
|
, m_marks(3)
|
|
, m_spaces(0)
|
|
, m_effect(NoEffect)
|
|
, m_effectIntensity(1.0)
|
|
{
|
|
}
|
|
|
|
QColor m_color;
|
|
double m_opacity;
|
|
double m_width;
|
|
LineStyle m_style;
|
|
double m_xCorners;
|
|
double m_yCorners;
|
|
int m_marks;
|
|
int m_spaces;
|
|
LineEffect m_effect;
|
|
double m_effectIntensity;
|
|
};
|
|
|
|
Annotation::Style::Style()
|
|
: d(new Private)
|
|
{
|
|
}
|
|
|
|
Annotation::Style::~Style()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
Annotation::Style::Style(const Style &other)
|
|
: d(new Private)
|
|
{
|
|
*d = *other.d;
|
|
}
|
|
|
|
Annotation::Style &Annotation::Style::operator=(const Style &other)
|
|
{
|
|
if (this != &other) {
|
|
*d = *other.d;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
void Annotation::Style::setColor(const QColor &color)
|
|
{
|
|
d->m_color = color;
|
|
}
|
|
|
|
QColor Annotation::Style::color() const
|
|
{
|
|
return d->m_color;
|
|
}
|
|
|
|
void Annotation::Style::setOpacity(double opacity)
|
|
{
|
|
d->m_opacity = opacity;
|
|
}
|
|
|
|
double Annotation::Style::opacity() const
|
|
{
|
|
return d->m_opacity;
|
|
}
|
|
|
|
void Annotation::Style::setWidth(double width)
|
|
{
|
|
d->m_width = width;
|
|
}
|
|
|
|
double Annotation::Style::width() const
|
|
{
|
|
return d->m_width;
|
|
}
|
|
|
|
void Annotation::Style::setLineStyle(LineStyle style)
|
|
{
|
|
d->m_style = style;
|
|
}
|
|
|
|
Annotation::LineStyle Annotation::Style::lineStyle() const
|
|
{
|
|
return d->m_style;
|
|
}
|
|
|
|
void Annotation::Style::setXCorners(double xCorners)
|
|
{
|
|
d->m_xCorners = xCorners;
|
|
}
|
|
|
|
double Annotation::Style::xCorners() const
|
|
{
|
|
return d->m_xCorners;
|
|
}
|
|
|
|
void Annotation::Style::setYCorners(double yCorners)
|
|
{
|
|
d->m_yCorners = yCorners;
|
|
}
|
|
|
|
double Annotation::Style::yCorners() const
|
|
{
|
|
return d->m_yCorners;
|
|
}
|
|
|
|
void Annotation::Style::setMarks(int marks)
|
|
{
|
|
d->m_marks = marks;
|
|
}
|
|
|
|
int Annotation::Style::marks() const
|
|
{
|
|
return d->m_marks;
|
|
}
|
|
|
|
void Annotation::Style::setSpaces(int spaces)
|
|
{
|
|
d->m_spaces = spaces;
|
|
}
|
|
|
|
int Annotation::Style::spaces() const
|
|
{
|
|
return d->m_spaces;
|
|
}
|
|
|
|
void Annotation::Style::setLineEffect(LineEffect effect)
|
|
{
|
|
d->m_effect = effect;
|
|
}
|
|
|
|
Annotation::LineEffect Annotation::Style::lineEffect() const
|
|
{
|
|
return d->m_effect;
|
|
}
|
|
|
|
void Annotation::Style::setEffectIntensity(double intensity)
|
|
{
|
|
d->m_effectIntensity = intensity;
|
|
}
|
|
|
|
double Annotation::Style::effectIntensity() const
|
|
{
|
|
return d->m_effectIntensity;
|
|
}
|
|
|
|
class Annotation::Window::Private
|
|
{
|
|
public:
|
|
Private()
|
|
: m_flags(-1)
|
|
, m_width(0)
|
|
, m_height(0)
|
|
{
|
|
}
|
|
|
|
int m_flags;
|
|
NormalizedPoint m_topLeft;
|
|
int m_width;
|
|
int m_height;
|
|
QString m_title;
|
|
QString m_summary;
|
|
};
|
|
|
|
Annotation::Window::Window()
|
|
: d(new Private)
|
|
{
|
|
}
|
|
|
|
Annotation::Window::~Window()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
Annotation::Window::Window(const Window &other)
|
|
: d(new Private)
|
|
{
|
|
*d = *other.d;
|
|
}
|
|
|
|
Annotation::Window &Annotation::Window::operator=(const Window &other)
|
|
{
|
|
if (this != &other) {
|
|
*d = *other.d;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
void Annotation::Window::setFlags(int flags)
|
|
{
|
|
d->m_flags = flags;
|
|
}
|
|
|
|
int Annotation::Window::flags() const
|
|
{
|
|
return d->m_flags;
|
|
}
|
|
|
|
void Annotation::Window::setTopLeft(const NormalizedPoint &point)
|
|
{
|
|
d->m_topLeft = point;
|
|
}
|
|
|
|
NormalizedPoint Annotation::Window::topLeft() const
|
|
{
|
|
return d->m_topLeft;
|
|
}
|
|
|
|
void Annotation::Window::setWidth(int width)
|
|
{
|
|
d->m_width = width;
|
|
}
|
|
|
|
int Annotation::Window::width() const
|
|
{
|
|
return d->m_width;
|
|
}
|
|
|
|
void Annotation::Window::setHeight(int height)
|
|
{
|
|
d->m_height = height;
|
|
}
|
|
|
|
int Annotation::Window::height() const
|
|
{
|
|
return d->m_height;
|
|
}
|
|
|
|
void Annotation::Window::setTitle(const QString &title)
|
|
{
|
|
d->m_title = title;
|
|
}
|
|
|
|
QString Annotation::Window::title() const
|
|
{
|
|
return d->m_title;
|
|
}
|
|
|
|
void Annotation::Window::setSummary(const QString &summary)
|
|
{
|
|
d->m_summary = summary;
|
|
}
|
|
|
|
QString Annotation::Window::summary() const
|
|
{
|
|
return d->m_summary;
|
|
}
|
|
|
|
class Annotation::Revision::Private
|
|
{
|
|
public:
|
|
Private()
|
|
: m_annotation(nullptr)
|
|
, m_scope(Reply)
|
|
, m_type(None)
|
|
{
|
|
}
|
|
|
|
Annotation *m_annotation;
|
|
RevisionScope m_scope;
|
|
RevisionType m_type;
|
|
};
|
|
|
|
Annotation::Revision::Revision()
|
|
: d(new Private)
|
|
{
|
|
}
|
|
|
|
Annotation::Revision::~Revision()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
Annotation::Revision::Revision(const Revision &other)
|
|
: d(new Private)
|
|
{
|
|
*d = *other.d;
|
|
}
|
|
|
|
Annotation::Revision &Annotation::Revision::operator=(const Revision &other)
|
|
{
|
|
if (this != &other) {
|
|
*d = *other.d;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
void Annotation::Revision::setAnnotation(Annotation *annotation)
|
|
{
|
|
d->m_annotation = annotation;
|
|
}
|
|
|
|
Annotation *Annotation::Revision::annotation() const
|
|
{
|
|
return d->m_annotation;
|
|
}
|
|
|
|
void Annotation::Revision::setScope(RevisionScope scope)
|
|
{
|
|
d->m_scope = scope;
|
|
}
|
|
|
|
Annotation::RevisionScope Annotation::Revision::scope() const
|
|
{
|
|
return d->m_scope;
|
|
}
|
|
|
|
void Annotation::Revision::setType(RevisionType type)
|
|
{
|
|
d->m_type = type;
|
|
}
|
|
|
|
Annotation::RevisionType Annotation::Revision::type() const
|
|
{
|
|
return d->m_type;
|
|
}
|
|
|
|
AnnotationPrivate::AnnotationPrivate()
|
|
: m_page(nullptr)
|
|
, m_flags(0)
|
|
, m_disposeFunc(nullptr)
|
|
{
|
|
}
|
|
|
|
AnnotationPrivate::~AnnotationPrivate()
|
|
{
|
|
// delete all children revisions
|
|
if (m_revisions.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
for (const Annotation::Revision &revision : std::as_const(m_revisions)) {
|
|
delete revision.annotation();
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *AnnotationPrivate::get(Annotation *a)
|
|
{
|
|
return a ? a->d_ptr : nullptr;
|
|
}
|
|
|
|
Annotation::Annotation(AnnotationPrivate &dd)
|
|
: d_ptr(&dd)
|
|
{
|
|
}
|
|
|
|
Annotation::Annotation(AnnotationPrivate &dd, const QDomNode &description)
|
|
: d_ptr(&dd)
|
|
{
|
|
d_ptr->setAnnotationProperties(description);
|
|
}
|
|
|
|
Annotation::~Annotation()
|
|
{
|
|
if (d_ptr->m_disposeFunc) {
|
|
d_ptr->m_disposeFunc(this);
|
|
}
|
|
|
|
delete d_ptr;
|
|
}
|
|
|
|
void Annotation::setAuthor(const QString &author)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_author = author;
|
|
}
|
|
|
|
QString Annotation::author() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_author;
|
|
}
|
|
|
|
void Annotation::setContents(const QString &contents)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_contents = contents;
|
|
}
|
|
|
|
QString Annotation::contents() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_contents;
|
|
}
|
|
|
|
void Annotation::setUniqueName(const QString &name)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_uniqueName = name;
|
|
}
|
|
|
|
QString Annotation::uniqueName() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_uniqueName;
|
|
}
|
|
|
|
void Annotation::setModificationDate(const QDateTime &date)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_modifyDate = date;
|
|
}
|
|
|
|
QDateTime Annotation::modificationDate() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_modifyDate;
|
|
}
|
|
|
|
void Annotation::setCreationDate(const QDateTime &date)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_creationDate = date;
|
|
}
|
|
|
|
QDateTime Annotation::creationDate() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_creationDate;
|
|
}
|
|
|
|
void Annotation::setFlags(int flags)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_flags = flags;
|
|
}
|
|
|
|
int Annotation::flags() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_flags;
|
|
}
|
|
|
|
void Annotation::setBoundingRectangle(const NormalizedRect &rectangle)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_boundary = rectangle;
|
|
d->resetTransformation();
|
|
if (d->m_page) {
|
|
d->transform(d->m_page->rotationMatrix());
|
|
}
|
|
}
|
|
|
|
NormalizedRect Annotation::boundingRectangle() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_boundary;
|
|
}
|
|
|
|
NormalizedRect Annotation::transformedBoundingRectangle() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_transformedBoundary;
|
|
}
|
|
|
|
void Annotation::translate(const NormalizedPoint &coord)
|
|
{
|
|
Q_D(Annotation);
|
|
d->translate(coord);
|
|
d->resetTransformation();
|
|
if (d->m_page) {
|
|
d->transform(d->m_page->rotationMatrix());
|
|
}
|
|
}
|
|
|
|
void Annotation::adjust(const NormalizedPoint &deltaCoord1, const NormalizedPoint &deltaCoord2)
|
|
{
|
|
Q_D(Annotation);
|
|
d->adjust(deltaCoord1, deltaCoord2);
|
|
d->resetTransformation();
|
|
if (d->m_page) {
|
|
d->transform(d->m_page->rotationMatrix());
|
|
}
|
|
}
|
|
|
|
bool Annotation::openDialogAfterCreation() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->openDialogAfterCreation();
|
|
}
|
|
|
|
Annotation::Style &Annotation::style()
|
|
{
|
|
Q_D(Annotation);
|
|
return d->m_style;
|
|
}
|
|
|
|
const Annotation::Style &Annotation::style() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_style;
|
|
}
|
|
|
|
Annotation::Window &Annotation::window()
|
|
{
|
|
Q_D(Annotation);
|
|
return d->m_window;
|
|
}
|
|
|
|
const Annotation::Window &Annotation::window() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_window;
|
|
}
|
|
|
|
QList<Annotation::Revision> &Annotation::revisions()
|
|
{
|
|
Q_D(Annotation);
|
|
return d->m_revisions;
|
|
}
|
|
|
|
const QList<Annotation::Revision> &Annotation::revisions() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_revisions;
|
|
}
|
|
|
|
void Annotation::setNativeId(const QVariant &id)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_nativeId = id;
|
|
}
|
|
|
|
QVariant Annotation::nativeId() const
|
|
{
|
|
Q_D(const Annotation);
|
|
return d->m_nativeId;
|
|
}
|
|
|
|
void Annotation::setDisposeDataFunction(DisposeDataFunction func)
|
|
{
|
|
Q_D(Annotation);
|
|
d->m_disposeFunc = func;
|
|
}
|
|
|
|
bool Annotation::canBeMoved() const
|
|
{
|
|
Q_D(const Annotation);
|
|
|
|
// Don't move annotations if they cannot be modified
|
|
if (!d->m_page || !d->m_page->m_doc->m_parent->canModifyPageAnnotation(this)) {
|
|
return false;
|
|
}
|
|
|
|
// highlight "requires" to be "bounded" to text, and that's tricky for now
|
|
if (subType() == AHighlight) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Annotation::canBeResized() const
|
|
{
|
|
Q_D(const Annotation);
|
|
|
|
// Don't resize annotations if they cannot be modified
|
|
if (!d->m_page || !d->m_page->m_doc->m_parent->canModifyPageAnnotation(this)) {
|
|
return false;
|
|
}
|
|
|
|
return d->canBeResized();
|
|
}
|
|
|
|
void Annotation::store(QDomNode &annNode, QDomDocument &document) const
|
|
{
|
|
Q_D(const Annotation);
|
|
// create [base] element of the annotation node
|
|
QDomElement e = document.createElement(QStringLiteral("base"));
|
|
annNode.appendChild(e);
|
|
|
|
// store -contents- attributes
|
|
if (!d->m_author.isEmpty()) {
|
|
e.setAttribute(QStringLiteral("author"), d->m_author);
|
|
}
|
|
if (!d->m_contents.isEmpty()) {
|
|
e.setAttribute(QStringLiteral("contents"), d->m_contents);
|
|
}
|
|
if (!d->m_uniqueName.isEmpty()) {
|
|
e.setAttribute(QStringLiteral("uniqueName"), d->m_uniqueName);
|
|
}
|
|
if (d->m_modifyDate.isValid()) {
|
|
e.setAttribute(QStringLiteral("modifyDate"), d->m_modifyDate.toString(Qt::ISODate));
|
|
}
|
|
if (d->m_creationDate.isValid()) {
|
|
e.setAttribute(QStringLiteral("creationDate"), d->m_creationDate.toString(Qt::ISODate));
|
|
}
|
|
|
|
// store -other- attributes
|
|
if (d->m_flags) { // Strip internal flags
|
|
e.setAttribute(QStringLiteral("flags"), d->m_flags & ~(External | ExternallyDrawn | BeingMoved | BeingResized));
|
|
}
|
|
if (d->m_style.color().isValid()) {
|
|
e.setAttribute(QStringLiteral("color"), d->m_style.color().name(QColor::HexArgb));
|
|
}
|
|
if (d->m_style.opacity() != 1.0) {
|
|
e.setAttribute(QStringLiteral("opacity"), QString::number(d->m_style.opacity()));
|
|
}
|
|
|
|
// Sub-Node-1 - boundary
|
|
QDomElement bE = document.createElement(QStringLiteral("boundary"));
|
|
e.appendChild(bE);
|
|
bE.setAttribute(QStringLiteral("l"), QString::number(d->m_boundary.left));
|
|
bE.setAttribute(QStringLiteral("t"), QString::number(d->m_boundary.top));
|
|
bE.setAttribute(QStringLiteral("r"), QString::number(d->m_boundary.right));
|
|
bE.setAttribute(QStringLiteral("b"), QString::number(d->m_boundary.bottom));
|
|
|
|
// Sub-Node-2 - penStyle
|
|
if (d->m_style.width() != 1 || d->m_style.lineStyle() != Solid || d->m_style.xCorners() != 0 || d->m_style.yCorners() != 0.0 || d->m_style.marks() != 3 || d->m_style.spaces() != 0) {
|
|
QDomElement psE = document.createElement(QStringLiteral("penStyle"));
|
|
e.appendChild(psE);
|
|
psE.setAttribute(QStringLiteral("width"), QString::number(d->m_style.width()));
|
|
psE.setAttribute(QStringLiteral("style"), (int)d->m_style.lineStyle());
|
|
psE.setAttribute(QStringLiteral("xcr"), QString::number(d->m_style.xCorners()));
|
|
psE.setAttribute(QStringLiteral("ycr"), QString::number(d->m_style.yCorners()));
|
|
psE.setAttribute(QStringLiteral("marks"), d->m_style.marks());
|
|
psE.setAttribute(QStringLiteral("spaces"), d->m_style.spaces());
|
|
}
|
|
|
|
// Sub-Node-3 - penEffect
|
|
if (d->m_style.lineEffect() != NoEffect || d->m_style.effectIntensity() != 1.0) {
|
|
QDomElement peE = document.createElement(QStringLiteral("penEffect"));
|
|
e.appendChild(peE);
|
|
peE.setAttribute(QStringLiteral("effect"), (int)d->m_style.lineEffect());
|
|
peE.setAttribute(QStringLiteral("intensity"), QString::number(d->m_style.effectIntensity()));
|
|
}
|
|
|
|
// Sub-Node-4 - window
|
|
if (d->m_window.flags() != -1 || !d->m_window.title().isEmpty() || !d->m_window.summary().isEmpty()) {
|
|
QDomElement wE = document.createElement(QStringLiteral("window"));
|
|
e.appendChild(wE);
|
|
wE.setAttribute(QStringLiteral("flags"), d->m_window.flags());
|
|
wE.setAttribute(QStringLiteral("top"), QString::number(d->m_window.topLeft().x));
|
|
wE.setAttribute(QStringLiteral("left"), QString::number(d->m_window.topLeft().y));
|
|
wE.setAttribute(QStringLiteral("width"), d->m_window.width());
|
|
wE.setAttribute(QStringLiteral("height"), d->m_window.height());
|
|
wE.setAttribute(QStringLiteral("title"), d->m_window.title());
|
|
wE.setAttribute(QStringLiteral("summary"), d->m_window.summary());
|
|
}
|
|
|
|
// create [revision] element of the annotation node (if any)
|
|
if (d->m_revisions.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
// add all revisions as children of revisions element
|
|
for (const Revision &revision : std::as_const(d->m_revisions)) {
|
|
// create revision element
|
|
QDomElement r = document.createElement(QStringLiteral("revision"));
|
|
annNode.appendChild(r);
|
|
// set element attributes
|
|
r.setAttribute(QStringLiteral("revScope"), (int)revision.scope());
|
|
r.setAttribute(QStringLiteral("revType"), (int)revision.type());
|
|
// use revision as the annotation element, so fill it up
|
|
AnnotationUtils::storeAnnotation(revision.annotation(), r, document);
|
|
}
|
|
}
|
|
|
|
QDomNode Annotation::getAnnotationPropertiesDomNode() const
|
|
{
|
|
QDomDocument doc(QStringLiteral("documentInfo"));
|
|
QDomElement node = doc.createElement(QStringLiteral("annotation"));
|
|
|
|
store(node, doc);
|
|
return node;
|
|
}
|
|
|
|
void Annotation::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
// Save off internal properties that aren't contained in node
|
|
Okular::PagePrivate *p = d_ptr->m_page;
|
|
QVariant nativeID = d_ptr->m_nativeId;
|
|
const int internalFlags = d_ptr->m_flags & (External | ExternallyDrawn | BeingMoved | BeingResized);
|
|
Annotation::DisposeDataFunction disposeFunc = d_ptr->m_disposeFunc;
|
|
|
|
// Replace AnnotationPrivate object with a fresh copy
|
|
AnnotationPrivate *new_d_ptr = d_ptr->getNewAnnotationPrivate();
|
|
delete (d_ptr);
|
|
d_ptr = new_d_ptr;
|
|
|
|
// Set the annotations properties from node
|
|
d_ptr->setAnnotationProperties(node);
|
|
|
|
// Restore internal properties
|
|
d_ptr->m_page = p;
|
|
d_ptr->m_nativeId = nativeID;
|
|
d_ptr->m_flags = d_ptr->m_flags | internalFlags;
|
|
d_ptr->m_disposeFunc = disposeFunc;
|
|
|
|
// Transform annotation to current page rotation
|
|
d_ptr->transform(d_ptr->m_page->rotationMatrix());
|
|
}
|
|
|
|
double AnnotationPrivate::distanceSqr(double x, double y, double xScale, double yScale) const
|
|
{
|
|
return m_transformedBoundary.distanceSqr(x, y, xScale, yScale);
|
|
}
|
|
|
|
void AnnotationPrivate::annotationTransform(const QTransform &matrix)
|
|
{
|
|
resetTransformation();
|
|
transform(matrix);
|
|
}
|
|
|
|
void AnnotationPrivate::transform(const QTransform &matrix)
|
|
{
|
|
m_transformedBoundary.transform(matrix);
|
|
}
|
|
|
|
void AnnotationPrivate::baseTransform(const QTransform &matrix)
|
|
{
|
|
m_boundary.transform(matrix);
|
|
}
|
|
|
|
void AnnotationPrivate::resetTransformation()
|
|
{
|
|
m_transformedBoundary = m_boundary;
|
|
}
|
|
|
|
void AnnotationPrivate::translate(const NormalizedPoint &coord)
|
|
{
|
|
m_boundary.left = m_boundary.left + coord.x;
|
|
m_boundary.right = m_boundary.right + coord.x;
|
|
m_boundary.top = m_boundary.top + coord.y;
|
|
m_boundary.bottom = m_boundary.bottom + coord.y;
|
|
}
|
|
|
|
void AnnotationPrivate::adjust(const NormalizedPoint &deltaCoord1, const NormalizedPoint &deltaCoord2)
|
|
{
|
|
m_boundary.left = m_boundary.left + qBound(-m_boundary.left, deltaCoord1.x, m_boundary.right - m_boundary.left);
|
|
m_boundary.top = m_boundary.top + qBound(-m_boundary.top, deltaCoord1.y, m_boundary.bottom - m_boundary.top);
|
|
;
|
|
m_boundary.right = m_boundary.right + qBound(m_boundary.left - m_boundary.right, deltaCoord2.x, 1. - m_boundary.right);
|
|
m_boundary.bottom = m_boundary.bottom + qBound(m_boundary.top - m_boundary.bottom, deltaCoord2.y, 1. - m_boundary.bottom);
|
|
}
|
|
|
|
bool AnnotationPrivate::openDialogAfterCreation() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void AnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
// get the [base] element of the annotation node
|
|
QDomElement e = AnnotationUtils::findChildElement(node, QStringLiteral("base"));
|
|
if (e.isNull()) {
|
|
return;
|
|
}
|
|
|
|
// parse -contents- attributes
|
|
if (e.hasAttribute(QStringLiteral("author"))) {
|
|
m_author = e.attribute(QStringLiteral("author"));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("contents"))) {
|
|
m_contents = e.attribute(QStringLiteral("contents"));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("uniqueName"))) {
|
|
m_uniqueName = e.attribute(QStringLiteral("uniqueName"));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("modifyDate"))) {
|
|
m_modifyDate = QDateTime::fromString(e.attribute(QStringLiteral("modifyDate")), Qt::ISODate);
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("creationDate"))) {
|
|
m_creationDate = QDateTime::fromString(e.attribute(QStringLiteral("creationDate")), Qt::ISODate);
|
|
}
|
|
|
|
// parse -other- attributes
|
|
if (e.hasAttribute(QStringLiteral("flags"))) {
|
|
m_flags = e.attribute(QStringLiteral("flags")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("color"))) {
|
|
m_style.setColor(QColor(e.attribute(QStringLiteral("color"))));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("opacity"))) {
|
|
m_style.setOpacity(e.attribute(QStringLiteral("opacity")).toDouble());
|
|
}
|
|
|
|
// parse -the-subnodes- (describing Style, Window, Revision(s) structures)
|
|
// Note: all subnodes if present must be 'attributes complete'
|
|
QDomNode eSubNode = e.firstChild();
|
|
while (eSubNode.isElement()) {
|
|
QDomElement ee = eSubNode.toElement();
|
|
eSubNode = eSubNode.nextSibling();
|
|
|
|
// parse boundary
|
|
if (ee.tagName() == QLatin1String("boundary")) {
|
|
m_boundary = NormalizedRect(ee.attribute(QStringLiteral("l")).toDouble(), ee.attribute(QStringLiteral("t")).toDouble(), ee.attribute(QStringLiteral("r")).toDouble(), ee.attribute(QStringLiteral("b")).toDouble());
|
|
}
|
|
// parse penStyle if not default
|
|
else if (ee.tagName() == QLatin1String("penStyle")) {
|
|
m_style.setWidth(ee.attribute(QStringLiteral("width")).toDouble());
|
|
m_style.setLineStyle((Annotation::LineStyle)ee.attribute(QStringLiteral("style")).toInt());
|
|
m_style.setXCorners(ee.attribute(QStringLiteral("xcr")).toDouble());
|
|
m_style.setYCorners(ee.attribute(QStringLiteral("ycr")).toDouble());
|
|
m_style.setMarks(ee.attribute(QStringLiteral("marks")).toInt());
|
|
m_style.setSpaces(ee.attribute(QStringLiteral("spaces")).toInt());
|
|
}
|
|
// parse effectStyle if not default
|
|
else if (ee.tagName() == QLatin1String("penEffect")) {
|
|
m_style.setLineEffect((Annotation::LineEffect)ee.attribute(QStringLiteral("effect")).toInt());
|
|
m_style.setEffectIntensity(ee.attribute(QStringLiteral("intensity")).toDouble());
|
|
}
|
|
// parse window if present
|
|
else if (ee.tagName() == QLatin1String("window")) {
|
|
m_window.setFlags(ee.attribute(QStringLiteral("flags")).toInt());
|
|
m_window.setTopLeft(NormalizedPoint(ee.attribute(QStringLiteral("top")).toDouble(), ee.attribute(QStringLiteral("left")).toDouble()));
|
|
m_window.setWidth(ee.attribute(QStringLiteral("width")).toInt());
|
|
m_window.setHeight(ee.attribute(QStringLiteral("height")).toInt());
|
|
m_window.setTitle(ee.attribute(QStringLiteral("title")));
|
|
m_window.setSummary(ee.attribute(QStringLiteral("summary")));
|
|
}
|
|
}
|
|
|
|
// get the [revisions] element of the annotation node
|
|
QDomNode revNode = node.firstChild();
|
|
for (; revNode.isElement(); revNode = revNode.nextSibling()) {
|
|
QDomElement revElement = revNode.toElement();
|
|
if (revElement.tagName() != QLatin1String("revision")) {
|
|
continue;
|
|
}
|
|
|
|
// compile the Revision structure crating annotation
|
|
Annotation::Revision revision;
|
|
revision.setScope((Annotation::RevisionScope)revElement.attribute(QStringLiteral("revScope")).toInt());
|
|
revision.setType((Annotation::RevisionType)revElement.attribute(QStringLiteral("revType")).toInt());
|
|
revision.setAnnotation(AnnotationUtils::createAnnotation(revElement));
|
|
|
|
// if annotation is valid, add revision to internal list
|
|
if (revision.annotation()) {
|
|
m_revisions.append(revision);
|
|
}
|
|
}
|
|
|
|
m_transformedBoundary = m_boundary;
|
|
}
|
|
|
|
bool AnnotationPrivate::canBeResized() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// END Annotation implementation
|
|
|
|
/** TextAnnotation [Annotation] */
|
|
|
|
class Okular::TextAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
TextAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, m_textType(TextAnnotation::Linked)
|
|
, m_textIcon(QStringLiteral("Comment"))
|
|
, m_inplaceAlign(0)
|
|
, m_inplaceIntent(TextAnnotation::Unknown)
|
|
{
|
|
}
|
|
|
|
void transform(const QTransform &matrix) override;
|
|
void baseTransform(const QTransform &matrix) override;
|
|
void resetTransformation() override;
|
|
void translate(const NormalizedPoint &coord) override;
|
|
bool openDialogAfterCreation() const override;
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
bool canBeResized() const override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
TextAnnotation::TextType m_textType;
|
|
QString m_textIcon;
|
|
QFont m_textFont;
|
|
QColor m_textColor;
|
|
int m_inplaceAlign;
|
|
NormalizedPoint m_inplaceCallout[3];
|
|
NormalizedPoint m_transformedInplaceCallout[3];
|
|
TextAnnotation::InplaceIntent m_inplaceIntent;
|
|
};
|
|
|
|
/*
|
|
The default textIcon for text annotation is Note as the PDF Reference says
|
|
*/
|
|
TextAnnotation::TextAnnotation()
|
|
: Annotation(*new TextAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
TextAnnotation::TextAnnotation(const QDomNode &description)
|
|
: Annotation(*new TextAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
TextAnnotation::~TextAnnotation()
|
|
{
|
|
}
|
|
|
|
void TextAnnotation::setTextType(TextType textType)
|
|
{
|
|
Q_D(TextAnnotation);
|
|
d->m_textType = textType;
|
|
}
|
|
|
|
TextAnnotation::TextType TextAnnotation::textType() const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
return d->m_textType;
|
|
}
|
|
|
|
void TextAnnotation::setTextIcon(const QString &icon)
|
|
{
|
|
Q_D(TextAnnotation);
|
|
d->m_textIcon = icon;
|
|
}
|
|
|
|
QString TextAnnotation::textIcon() const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
return d->m_textIcon;
|
|
}
|
|
|
|
void TextAnnotation::setTextFont(const QFont &font)
|
|
{
|
|
Q_D(TextAnnotation);
|
|
d->m_textFont = font;
|
|
}
|
|
|
|
QFont TextAnnotation::textFont() const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
return d->m_textFont;
|
|
}
|
|
|
|
void TextAnnotation::setTextColor(const QColor &color)
|
|
{
|
|
Q_D(TextAnnotation);
|
|
d->m_textColor = color;
|
|
}
|
|
|
|
QColor TextAnnotation::textColor() const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
return d->m_textColor;
|
|
}
|
|
|
|
void TextAnnotation::setInplaceAlignment(int alignment)
|
|
{
|
|
Q_D(TextAnnotation);
|
|
d->m_inplaceAlign = alignment;
|
|
}
|
|
|
|
int TextAnnotation::inplaceAlignment() const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
return d->m_inplaceAlign;
|
|
}
|
|
|
|
void TextAnnotation::setInplaceCallout(const NormalizedPoint &point, int index)
|
|
{
|
|
if (index < 0 || index > 2) {
|
|
return;
|
|
}
|
|
|
|
Q_D(TextAnnotation);
|
|
d->m_inplaceCallout[index] = point;
|
|
}
|
|
|
|
NormalizedPoint TextAnnotation::inplaceCallout(int index) const
|
|
{
|
|
if (index < 0 || index > 2) {
|
|
return NormalizedPoint();
|
|
}
|
|
|
|
Q_D(const TextAnnotation);
|
|
return d->m_inplaceCallout[index];
|
|
}
|
|
|
|
NormalizedPoint TextAnnotation::transformedInplaceCallout(int index) const
|
|
{
|
|
if (index < 0 || index > 2) {
|
|
return NormalizedPoint();
|
|
}
|
|
|
|
Q_D(const TextAnnotation);
|
|
return d->m_transformedInplaceCallout[index];
|
|
}
|
|
|
|
void TextAnnotation::setInplaceIntent(InplaceIntent intent)
|
|
{
|
|
Q_D(TextAnnotation);
|
|
d->m_inplaceIntent = intent;
|
|
}
|
|
|
|
TextAnnotation::InplaceIntent TextAnnotation::inplaceIntent() const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
return d->m_inplaceIntent;
|
|
}
|
|
|
|
Annotation::SubType TextAnnotation::subType() const
|
|
{
|
|
return AText;
|
|
}
|
|
|
|
void TextAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const TextAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [text] element
|
|
QDomElement textElement = document.createElement(QStringLiteral("text"));
|
|
node.appendChild(textElement);
|
|
|
|
// store the optional attributes
|
|
if (d->m_textType != Linked) {
|
|
textElement.setAttribute(QStringLiteral("type"), (int)d->m_textType);
|
|
}
|
|
if (!d->m_textIcon.isEmpty()) {
|
|
textElement.setAttribute(QStringLiteral("icon"), d->m_textIcon);
|
|
}
|
|
if (d->m_textFont != QApplication::font()) {
|
|
textElement.setAttribute(QStringLiteral("font"), d->m_textFont.toString());
|
|
}
|
|
if (d->m_textColor.isValid()) {
|
|
textElement.setAttribute(QStringLiteral("fontColor"), d->m_textColor.name());
|
|
}
|
|
if (d->m_inplaceAlign) {
|
|
textElement.setAttribute(QStringLiteral("align"), d->m_inplaceAlign);
|
|
}
|
|
if (d->m_inplaceIntent != Unknown) {
|
|
textElement.setAttribute(QStringLiteral("intent"), (int)d->m_inplaceIntent);
|
|
}
|
|
|
|
// Sub-Node - callout
|
|
if (d->m_inplaceCallout[0].x != 0.0) {
|
|
QDomElement calloutElement = document.createElement(QStringLiteral("callout"));
|
|
textElement.appendChild(calloutElement);
|
|
calloutElement.setAttribute(QStringLiteral("ax"), QString::number(d->m_inplaceCallout[0].x));
|
|
calloutElement.setAttribute(QStringLiteral("ay"), QString::number(d->m_inplaceCallout[0].y));
|
|
calloutElement.setAttribute(QStringLiteral("bx"), QString::number(d->m_inplaceCallout[1].x));
|
|
calloutElement.setAttribute(QStringLiteral("by"), QString::number(d->m_inplaceCallout[1].y));
|
|
calloutElement.setAttribute(QStringLiteral("cx"), QString::number(d->m_inplaceCallout[2].x));
|
|
calloutElement.setAttribute(QStringLiteral("cy"), QString::number(d->m_inplaceCallout[2].y));
|
|
}
|
|
}
|
|
|
|
void TextAnnotationPrivate::transform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::transform(matrix);
|
|
|
|
for (NormalizedPoint &np : m_transformedInplaceCallout) {
|
|
np.transform(matrix);
|
|
}
|
|
}
|
|
|
|
void TextAnnotationPrivate::baseTransform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::baseTransform(matrix);
|
|
|
|
for (NormalizedPoint &np : m_inplaceCallout) {
|
|
np.transform(matrix);
|
|
}
|
|
}
|
|
|
|
void TextAnnotationPrivate::resetTransformation()
|
|
{
|
|
AnnotationPrivate::resetTransformation();
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
m_transformedInplaceCallout[i] = m_inplaceCallout[i];
|
|
}
|
|
}
|
|
|
|
void TextAnnotationPrivate::translate(const NormalizedPoint &coord)
|
|
{
|
|
AnnotationPrivate::translate(coord);
|
|
|
|
#define ADD_COORD(c1, c2) \
|
|
{ \
|
|
c1.x = c1.x + c2.x; \
|
|
c1.y = c1.y + c2.y; \
|
|
}
|
|
ADD_COORD(m_inplaceCallout[0], coord)
|
|
ADD_COORD(m_inplaceCallout[1], coord)
|
|
ADD_COORD(m_inplaceCallout[2], coord)
|
|
#undef ADD_COORD
|
|
}
|
|
|
|
bool TextAnnotationPrivate::openDialogAfterCreation() const
|
|
{
|
|
return (m_textType == Okular::TextAnnotation::Linked) || (m_inplaceIntent == TextAnnotation::InplaceIntent::Unknown);
|
|
}
|
|
|
|
void TextAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'text' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("text")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the attributes
|
|
if (e.hasAttribute(QStringLiteral("type"))) {
|
|
m_textType = (TextAnnotation::TextType)e.attribute(QStringLiteral("type")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("icon"))) {
|
|
m_textIcon = e.attribute(QStringLiteral("icon"));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("font"))) {
|
|
m_textFont.fromString(e.attribute(QStringLiteral("font")));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("fontColor"))) {
|
|
m_textColor = QColor(e.attribute(QStringLiteral("fontColor")));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("align"))) {
|
|
m_inplaceAlign = e.attribute(QStringLiteral("align")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("intent"))) {
|
|
m_inplaceIntent = (TextAnnotation::InplaceIntent)e.attribute(QStringLiteral("intent")).toInt();
|
|
}
|
|
|
|
// parse the subnodes
|
|
QDomNode eSubNode = e.firstChild();
|
|
while (eSubNode.isElement()) {
|
|
QDomElement ee = eSubNode.toElement();
|
|
eSubNode = eSubNode.nextSibling();
|
|
|
|
if (ee.tagName() == QLatin1String("escapedText")) {
|
|
m_contents = ee.firstChild().toCDATASection().data();
|
|
} else if (ee.tagName() == QLatin1String("callout")) {
|
|
m_inplaceCallout[0].x = ee.attribute(QStringLiteral("ax")).toDouble();
|
|
m_inplaceCallout[0].y = ee.attribute(QStringLiteral("ay")).toDouble();
|
|
m_inplaceCallout[1].x = ee.attribute(QStringLiteral("bx")).toDouble();
|
|
m_inplaceCallout[1].y = ee.attribute(QStringLiteral("by")).toDouble();
|
|
m_inplaceCallout[2].x = ee.attribute(QStringLiteral("cx")).toDouble();
|
|
m_inplaceCallout[2].y = ee.attribute(QStringLiteral("cy")).toDouble();
|
|
}
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
m_transformedInplaceCallout[i] = m_inplaceCallout[i];
|
|
}
|
|
}
|
|
|
|
bool TextAnnotationPrivate::canBeResized() const
|
|
{
|
|
if (m_textType != TextAnnotation::Linked) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
AnnotationPrivate *TextAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new TextAnnotationPrivate();
|
|
}
|
|
|
|
/** LineAnnotation [Annotation] */
|
|
|
|
class Okular::LineAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
LineAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, m_lineStartStyle(LineAnnotation::None)
|
|
, m_lineEndStyle(LineAnnotation::None)
|
|
, m_lineClosed(false)
|
|
, m_lineShowCaption(false)
|
|
, m_lineLeadingFwdPt(0)
|
|
, m_lineLeadingBackPt(0)
|
|
, m_lineIntent(LineAnnotation::Unknown)
|
|
{
|
|
}
|
|
|
|
void transform(const QTransform &matrix) override;
|
|
void baseTransform(const QTransform &matrix) override;
|
|
void resetTransformation() override;
|
|
void translate(const NormalizedPoint &coord) override;
|
|
double distanceSqr(double x, double y, double xScale, double yScale) const override;
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
QList<NormalizedPoint> m_linePoints;
|
|
QList<NormalizedPoint> m_transformedLinePoints;
|
|
LineAnnotation::TermStyle m_lineStartStyle;
|
|
LineAnnotation::TermStyle m_lineEndStyle;
|
|
bool m_lineClosed : 1;
|
|
bool m_lineShowCaption : 1;
|
|
QColor m_lineInnerColor;
|
|
double m_lineLeadingFwdPt;
|
|
double m_lineLeadingBackPt;
|
|
LineAnnotation::LineIntent m_lineIntent;
|
|
};
|
|
|
|
LineAnnotation::LineAnnotation()
|
|
: Annotation(*new LineAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
LineAnnotation::LineAnnotation(const QDomNode &description)
|
|
: Annotation(*new LineAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
LineAnnotation::~LineAnnotation()
|
|
{
|
|
}
|
|
|
|
void LineAnnotation::setLinePoints(const QList<NormalizedPoint> &points)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_linePoints = points;
|
|
}
|
|
|
|
QList<NormalizedPoint> LineAnnotation::linePoints() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_linePoints;
|
|
}
|
|
|
|
QList<NormalizedPoint> LineAnnotation::transformedLinePoints() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_transformedLinePoints;
|
|
}
|
|
|
|
void LineAnnotation::setLineStartStyle(TermStyle style)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineStartStyle = style;
|
|
}
|
|
|
|
LineAnnotation::TermStyle LineAnnotation::lineStartStyle() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineStartStyle;
|
|
}
|
|
|
|
void LineAnnotation::setLineEndStyle(TermStyle style)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineEndStyle = style;
|
|
}
|
|
|
|
LineAnnotation::TermStyle LineAnnotation::lineEndStyle() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineEndStyle;
|
|
}
|
|
|
|
void LineAnnotation::setLineClosed(bool closed)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineClosed = closed;
|
|
}
|
|
|
|
bool LineAnnotation::lineClosed() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineClosed;
|
|
}
|
|
|
|
void LineAnnotation::setLineInnerColor(const QColor &color)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineInnerColor = color;
|
|
}
|
|
|
|
QColor LineAnnotation::lineInnerColor() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineInnerColor;
|
|
}
|
|
|
|
void LineAnnotation::setLineLeadingForwardPoint(double point)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineLeadingFwdPt = point;
|
|
}
|
|
|
|
double LineAnnotation::lineLeadingForwardPoint() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineLeadingFwdPt;
|
|
}
|
|
|
|
void LineAnnotation::setLineLeadingBackwardPoint(double point)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineLeadingBackPt = point;
|
|
}
|
|
|
|
double LineAnnotation::lineLeadingBackwardPoint() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineLeadingBackPt;
|
|
}
|
|
|
|
void LineAnnotation::setShowCaption(bool show)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineShowCaption = show;
|
|
}
|
|
|
|
bool LineAnnotation::showCaption() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineShowCaption;
|
|
}
|
|
|
|
void LineAnnotation::setLineIntent(LineIntent intent)
|
|
{
|
|
Q_D(LineAnnotation);
|
|
d->m_lineIntent = intent;
|
|
}
|
|
|
|
LineAnnotation::LineIntent LineAnnotation::lineIntent() const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
return d->m_lineIntent;
|
|
}
|
|
|
|
Annotation::SubType LineAnnotation::subType() const
|
|
{
|
|
return ALine;
|
|
}
|
|
|
|
void LineAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const LineAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [line] element
|
|
QDomElement lineElement = document.createElement(QStringLiteral("line"));
|
|
node.appendChild(lineElement);
|
|
|
|
// store the attributes
|
|
if (d->m_lineStartStyle != None) {
|
|
lineElement.setAttribute(QStringLiteral("startStyle"), (int)d->m_lineStartStyle);
|
|
}
|
|
if (d->m_lineEndStyle != None) {
|
|
lineElement.setAttribute(QStringLiteral("endStyle"), (int)d->m_lineEndStyle);
|
|
}
|
|
if (d->m_lineClosed) {
|
|
lineElement.setAttribute(QStringLiteral("closed"), d->m_lineClosed);
|
|
}
|
|
if (d->m_lineInnerColor.isValid()) {
|
|
lineElement.setAttribute(QStringLiteral("innerColor"), d->m_lineInnerColor.name());
|
|
}
|
|
if (d->m_lineLeadingFwdPt != 0.0) {
|
|
lineElement.setAttribute(QStringLiteral("leadFwd"), QString::number(d->m_lineLeadingFwdPt));
|
|
}
|
|
if (d->m_lineLeadingBackPt != 0.0) {
|
|
lineElement.setAttribute(QStringLiteral("leadBack"), QString::number(d->m_lineLeadingBackPt));
|
|
}
|
|
if (d->m_lineShowCaption) {
|
|
lineElement.setAttribute(QStringLiteral("showCaption"), d->m_lineShowCaption);
|
|
}
|
|
if (d->m_lineIntent != Unknown) {
|
|
lineElement.setAttribute(QStringLiteral("intent"), d->m_lineIntent);
|
|
}
|
|
|
|
// append the list of points
|
|
int points = d->m_linePoints.count();
|
|
if (points > 1) {
|
|
QList<NormalizedPoint>::const_iterator it = d->m_linePoints.begin(), end = d->m_linePoints.end();
|
|
while (it != end) {
|
|
const NormalizedPoint &p = *it;
|
|
QDomElement pElement = document.createElement(QStringLiteral("point"));
|
|
lineElement.appendChild(pElement);
|
|
pElement.setAttribute(QStringLiteral("x"), QString::number(p.x));
|
|
pElement.setAttribute(QStringLiteral("y"), QString::number(p.y));
|
|
++it; // to avoid loop
|
|
}
|
|
}
|
|
}
|
|
|
|
void LineAnnotationPrivate::transform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::transform(matrix);
|
|
|
|
QMutableListIterator<NormalizedPoint> it(m_transformedLinePoints);
|
|
while (it.hasNext()) {
|
|
it.next().transform(matrix);
|
|
}
|
|
}
|
|
|
|
void LineAnnotationPrivate::baseTransform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::baseTransform(matrix);
|
|
|
|
QMutableListIterator<NormalizedPoint> it(m_linePoints);
|
|
while (it.hasNext()) {
|
|
it.next().transform(matrix);
|
|
}
|
|
}
|
|
|
|
void LineAnnotationPrivate::resetTransformation()
|
|
{
|
|
AnnotationPrivate::resetTransformation();
|
|
|
|
m_transformedLinePoints = m_linePoints;
|
|
}
|
|
|
|
void LineAnnotationPrivate::translate(const NormalizedPoint &coord)
|
|
{
|
|
AnnotationPrivate::translate(coord);
|
|
|
|
QMutableListIterator<NormalizedPoint> it(m_linePoints);
|
|
while (it.hasNext()) {
|
|
NormalizedPoint &p = it.next();
|
|
p.x = p.x + coord.x;
|
|
p.y = p.y + coord.y;
|
|
}
|
|
}
|
|
|
|
void LineAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'line' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("line")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the attributes
|
|
if (e.hasAttribute(QStringLiteral("startStyle"))) {
|
|
m_lineStartStyle = (LineAnnotation::TermStyle)e.attribute(QStringLiteral("startStyle")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("endStyle"))) {
|
|
m_lineEndStyle = (LineAnnotation::TermStyle)e.attribute(QStringLiteral("endStyle")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("closed"))) {
|
|
m_lineClosed = e.attribute(QStringLiteral("closed")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("innerColor"))) {
|
|
m_lineInnerColor = QColor(e.attribute(QStringLiteral("innerColor")));
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("leadFwd"))) {
|
|
m_lineLeadingFwdPt = e.attribute(QStringLiteral("leadFwd")).toDouble();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("leadBack"))) {
|
|
m_lineLeadingBackPt = e.attribute(QStringLiteral("leadBack")).toDouble();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("showCaption"))) {
|
|
m_lineShowCaption = e.attribute(QStringLiteral("showCaption")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("intent"))) {
|
|
m_lineIntent = (LineAnnotation::LineIntent)e.attribute(QStringLiteral("intent")).toInt();
|
|
}
|
|
|
|
// parse all 'point' subnodes
|
|
QDomNode pointNode = e.firstChild();
|
|
while (pointNode.isElement()) {
|
|
QDomElement pe = pointNode.toElement();
|
|
pointNode = pointNode.nextSibling();
|
|
|
|
if (pe.tagName() != QLatin1String("point")) {
|
|
continue;
|
|
}
|
|
|
|
NormalizedPoint p;
|
|
p.x = pe.attribute(QStringLiteral("x"), QStringLiteral("0.0")).toDouble();
|
|
p.y = pe.attribute(QStringLiteral("y"), QStringLiteral("0.0")).toDouble();
|
|
m_linePoints.append(p);
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
|
|
m_transformedLinePoints = m_linePoints;
|
|
}
|
|
|
|
AnnotationPrivate *LineAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new LineAnnotationPrivate();
|
|
}
|
|
|
|
double LineAnnotationPrivate::distanceSqr(double x, double y, double xScale, double yScale) const
|
|
{
|
|
QList<NormalizedPoint> transformedLinePoints = m_transformedLinePoints;
|
|
|
|
if (m_lineClosed) { // Close the path
|
|
transformedLinePoints.append(transformedLinePoints.first());
|
|
}
|
|
|
|
if (m_lineInnerColor.isValid()) {
|
|
QPolygonF polygon;
|
|
for (const NormalizedPoint &p : std::as_const(transformedLinePoints)) {
|
|
polygon.append(QPointF(p.x, p.y));
|
|
}
|
|
|
|
if (polygon.containsPoint(QPointF(x, y), Qt::WindingFill)) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return strokeDistance(::distanceSqr(x, y, xScale, yScale, transformedLinePoints), m_style.width() * xScale / (m_page->m_width * 2));
|
|
}
|
|
|
|
/** GeomAnnotation [Annotation] */
|
|
|
|
class Okular::GeomAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
GeomAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, m_geomType(GeomAnnotation::InscribedSquare)
|
|
{
|
|
}
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
bool canBeResized() const override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
double distanceSqr(double x, double y, double xScale, double yScale) const override;
|
|
|
|
GeomAnnotation::GeomType m_geomType;
|
|
QColor m_geomInnerColor;
|
|
};
|
|
|
|
GeomAnnotation::GeomAnnotation()
|
|
: Annotation(*new GeomAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
GeomAnnotation::GeomAnnotation(const QDomNode &description)
|
|
: Annotation(*new GeomAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
GeomAnnotation::~GeomAnnotation()
|
|
{
|
|
}
|
|
|
|
void GeomAnnotation::setGeometricalType(GeomType type)
|
|
{
|
|
Q_D(GeomAnnotation);
|
|
d->m_geomType = type;
|
|
}
|
|
|
|
GeomAnnotation::GeomType GeomAnnotation::geometricalType() const
|
|
{
|
|
Q_D(const GeomAnnotation);
|
|
return d->m_geomType;
|
|
}
|
|
|
|
void GeomAnnotation::setGeometricalInnerColor(const QColor &color)
|
|
{
|
|
Q_D(GeomAnnotation);
|
|
d->m_geomInnerColor = color;
|
|
}
|
|
|
|
QColor GeomAnnotation::geometricalInnerColor() const
|
|
{
|
|
Q_D(const GeomAnnotation);
|
|
return d->m_geomInnerColor;
|
|
}
|
|
|
|
Annotation::SubType GeomAnnotation::subType() const
|
|
{
|
|
return AGeom;
|
|
}
|
|
|
|
void GeomAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const GeomAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [geom] element
|
|
QDomElement geomElement = document.createElement(QStringLiteral("geom"));
|
|
node.appendChild(geomElement);
|
|
|
|
// append the optional attributes
|
|
if (d->m_geomType != InscribedSquare) {
|
|
geomElement.setAttribute(QStringLiteral("type"), (int)d->m_geomType);
|
|
}
|
|
if (d->m_geomInnerColor.isValid()) {
|
|
geomElement.setAttribute(QStringLiteral("color"), d->m_geomInnerColor.name());
|
|
}
|
|
}
|
|
|
|
void GeomAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
// loop through the whole children looking for a 'geom' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("geom")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the attributes
|
|
if (e.hasAttribute(QStringLiteral("type"))) {
|
|
m_geomType = (GeomAnnotation::GeomType)e.attribute(QStringLiteral("type")).toInt();
|
|
}
|
|
if (e.hasAttribute(QStringLiteral("color"))) {
|
|
m_geomInnerColor = QColor(e.attribute(QStringLiteral("color")));
|
|
}
|
|
// compatibility
|
|
if (e.hasAttribute(QStringLiteral("width"))) {
|
|
m_style.setWidth(e.attribute(QStringLiteral("width")).toInt());
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool GeomAnnotationPrivate::canBeResized() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
AnnotationPrivate *GeomAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new GeomAnnotationPrivate();
|
|
}
|
|
|
|
double GeomAnnotationPrivate::distanceSqr(double x, double y, double xScale, double yScale) const
|
|
{
|
|
double distance = 0;
|
|
// the line thickness is applied unevenly (only on the "inside") - account for this
|
|
bool withinShape = false;
|
|
switch (m_geomType) {
|
|
case GeomAnnotation::InscribedCircle: {
|
|
// calculate the center point and focus lengths of the ellipse
|
|
const double centerX = (m_transformedBoundary.left + m_transformedBoundary.right) / 2.0;
|
|
const double centerY = (m_transformedBoundary.top + m_transformedBoundary.bottom) / 2.0;
|
|
const double focusX = (m_transformedBoundary.right - centerX);
|
|
const double focusY = (m_transformedBoundary.bottom - centerY);
|
|
|
|
const double focusXSqr = pow(focusX, 2);
|
|
const double focusYSqr = pow(focusY, 2);
|
|
|
|
// to calculate the distance from the ellipse, we will first find the point "projection"
|
|
// that lies on the ellipse and is closest to the point (x,y)
|
|
// This point can obviously be written as "center + lambda(inputPoint - center)".
|
|
// Because the point lies on the ellipse, we know that:
|
|
// 1 = ((center.x - projection.x)/focusX)^2 + ((center.y - projection.y)/focusY)^2
|
|
// After filling in projection.x = center.x + lambda * (inputPoint.x - center.x)
|
|
// and its y-equivalent, we can solve for lambda:
|
|
const double lambda = sqrt(focusXSqr * focusYSqr / (focusYSqr * pow(x - centerX, 2) + focusXSqr * pow(y - centerY, 2)));
|
|
|
|
// if the ellipse is filled, we treat all points within as "on" it
|
|
if (lambda > 1) {
|
|
if (m_geomInnerColor.isValid()) {
|
|
return 0;
|
|
} else {
|
|
withinShape = true;
|
|
}
|
|
}
|
|
|
|
// otherwise we calculate the squared distance from the projected point on the ellipse
|
|
NormalizedPoint projection(centerX, centerY);
|
|
projection.x += lambda * (x - centerX);
|
|
projection.y += lambda * (y - centerY);
|
|
|
|
distance = projection.distanceSqr(x, y, xScale, yScale);
|
|
break;
|
|
}
|
|
|
|
case GeomAnnotation::InscribedSquare:
|
|
// if the square is filled, only check the bounding box
|
|
if (m_geomInnerColor.isValid()) {
|
|
return AnnotationPrivate::distanceSqr(x, y, xScale, yScale);
|
|
}
|
|
|
|
const QList<NormalizedPoint> edges = {NormalizedPoint(m_transformedBoundary.left, m_transformedBoundary.top),
|
|
NormalizedPoint(m_transformedBoundary.right, m_transformedBoundary.top),
|
|
NormalizedPoint(m_transformedBoundary.right, m_transformedBoundary.bottom),
|
|
NormalizedPoint(m_transformedBoundary.left, m_transformedBoundary.bottom),
|
|
NormalizedPoint(m_transformedBoundary.left, m_transformedBoundary.top)};
|
|
distance = ::distanceSqr(x, y, xScale, yScale, edges);
|
|
|
|
if (m_transformedBoundary.contains(x, y)) {
|
|
withinShape = true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
if (withinShape) {
|
|
distance = strokeDistance(distance, m_style.width() * xScale / m_page->m_width);
|
|
}
|
|
|
|
return distance;
|
|
}
|
|
|
|
/** HighlightAnnotation [Annotation] */
|
|
|
|
class HighlightAnnotation::Quad::Private
|
|
{
|
|
public:
|
|
Private()
|
|
: m_capStart(false)
|
|
, m_capEnd(false)
|
|
, m_feather(0.0)
|
|
{
|
|
}
|
|
|
|
NormalizedPoint m_points[4];
|
|
NormalizedPoint m_transformedPoints[4];
|
|
bool m_capStart : 1;
|
|
bool m_capEnd : 1;
|
|
double m_feather;
|
|
};
|
|
|
|
HighlightAnnotation::Quad::Quad()
|
|
: d(new Private)
|
|
{
|
|
}
|
|
|
|
HighlightAnnotation::Quad::~Quad()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
HighlightAnnotation::Quad::Quad(const Quad &other)
|
|
: d(new Private)
|
|
{
|
|
*d = *other.d;
|
|
}
|
|
|
|
HighlightAnnotation::Quad &HighlightAnnotation::Quad::operator=(const Quad &other)
|
|
{
|
|
if (this != &other) {
|
|
*d = *other.d;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
void HighlightAnnotation::Quad::setPoint(const NormalizedPoint &point, int index)
|
|
{
|
|
if (index < 0 || index > 3) {
|
|
return;
|
|
}
|
|
|
|
d->m_points[index] = point;
|
|
}
|
|
|
|
NormalizedPoint HighlightAnnotation::Quad::point(int index) const
|
|
{
|
|
if (index < 0 || index > 3) {
|
|
return NormalizedPoint();
|
|
}
|
|
|
|
return d->m_points[index];
|
|
}
|
|
|
|
NormalizedPoint HighlightAnnotation::Quad::transformedPoint(int index) const
|
|
{
|
|
if (index < 0 || index > 3) {
|
|
return NormalizedPoint();
|
|
}
|
|
|
|
return d->m_transformedPoints[index];
|
|
}
|
|
|
|
void HighlightAnnotation::Quad::setCapStart(bool value)
|
|
{
|
|
d->m_capStart = value;
|
|
}
|
|
|
|
bool HighlightAnnotation::Quad::capStart() const
|
|
{
|
|
return d->m_capStart;
|
|
}
|
|
|
|
void HighlightAnnotation::Quad::setCapEnd(bool value)
|
|
{
|
|
d->m_capEnd = value;
|
|
}
|
|
|
|
bool HighlightAnnotation::Quad::capEnd() const
|
|
{
|
|
return d->m_capEnd;
|
|
}
|
|
|
|
void HighlightAnnotation::Quad::setFeather(double width)
|
|
{
|
|
d->m_feather = width;
|
|
}
|
|
|
|
double HighlightAnnotation::Quad::feather() const
|
|
{
|
|
return d->m_feather;
|
|
}
|
|
|
|
void HighlightAnnotation::Quad::transform(const QTransform &matrix)
|
|
{
|
|
for (int i = 0; i < 4; ++i) {
|
|
d->m_transformedPoints[i] = d->m_points[i];
|
|
d->m_transformedPoints[i].transform(matrix);
|
|
}
|
|
}
|
|
|
|
class Okular::HighlightAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
HighlightAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, m_highlightType(HighlightAnnotation::Highlight)
|
|
{
|
|
}
|
|
|
|
void transform(const QTransform &matrix) override;
|
|
void baseTransform(const QTransform &matrix) override;
|
|
double distanceSqr(double x, double y, double xScale, double yScale) const override;
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
HighlightAnnotation::HighlightType m_highlightType;
|
|
QList<HighlightAnnotation::Quad> m_highlightQuads;
|
|
};
|
|
|
|
HighlightAnnotation::HighlightAnnotation()
|
|
: Annotation(*new HighlightAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
HighlightAnnotation::HighlightAnnotation(const QDomNode &description)
|
|
: Annotation(*new HighlightAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
HighlightAnnotation::~HighlightAnnotation()
|
|
{
|
|
}
|
|
|
|
void HighlightAnnotation::setHighlightType(HighlightType type)
|
|
{
|
|
Q_D(HighlightAnnotation);
|
|
d->m_highlightType = type;
|
|
}
|
|
|
|
HighlightAnnotation::HighlightType HighlightAnnotation::highlightType() const
|
|
{
|
|
Q_D(const HighlightAnnotation);
|
|
return d->m_highlightType;
|
|
}
|
|
|
|
QList<HighlightAnnotation::Quad> &HighlightAnnotation::highlightQuads()
|
|
{
|
|
Q_D(HighlightAnnotation);
|
|
return d->m_highlightQuads;
|
|
}
|
|
|
|
const QList<HighlightAnnotation::Quad> &HighlightAnnotation::highlightQuads() const
|
|
{
|
|
Q_D(const HighlightAnnotation);
|
|
return d->m_highlightQuads;
|
|
}
|
|
|
|
void HighlightAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const HighlightAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [hl] element
|
|
QDomElement hlElement = document.createElement(QStringLiteral("hl"));
|
|
node.appendChild(hlElement);
|
|
|
|
// append the optional attributes
|
|
if (d->m_highlightType != Highlight) {
|
|
hlElement.setAttribute(QStringLiteral("type"), (int)d->m_highlightType);
|
|
}
|
|
if (d->m_highlightQuads.count() < 1) {
|
|
return;
|
|
}
|
|
// append highlight quads, all children describe quads
|
|
QList<Quad>::const_iterator it = d->m_highlightQuads.begin(), end = d->m_highlightQuads.end();
|
|
for (; it != end; ++it) {
|
|
QDomElement quadElement = document.createElement(QStringLiteral("quad"));
|
|
hlElement.appendChild(quadElement);
|
|
const Quad &q = *it;
|
|
quadElement.setAttribute(QStringLiteral("ax"), QString::number(q.point(0).x));
|
|
quadElement.setAttribute(QStringLiteral("ay"), QString::number(q.point(0).y));
|
|
quadElement.setAttribute(QStringLiteral("bx"), QString::number(q.point(1).x));
|
|
quadElement.setAttribute(QStringLiteral("by"), QString::number(q.point(1).y));
|
|
quadElement.setAttribute(QStringLiteral("cx"), QString::number(q.point(2).x));
|
|
quadElement.setAttribute(QStringLiteral("cy"), QString::number(q.point(2).y));
|
|
quadElement.setAttribute(QStringLiteral("dx"), QString::number(q.point(3).x));
|
|
quadElement.setAttribute(QStringLiteral("dy"), QString::number(q.point(3).y));
|
|
if (q.capStart()) {
|
|
quadElement.setAttribute(QStringLiteral("start"), 1);
|
|
}
|
|
if (q.capEnd()) {
|
|
quadElement.setAttribute(QStringLiteral("end"), 1);
|
|
}
|
|
quadElement.setAttribute(QStringLiteral("feather"), QString::number(q.feather()));
|
|
}
|
|
}
|
|
|
|
Annotation::SubType HighlightAnnotation::subType() const
|
|
{
|
|
return AHighlight;
|
|
}
|
|
|
|
void HighlightAnnotationPrivate::transform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::transform(matrix);
|
|
|
|
QMutableListIterator<HighlightAnnotation::Quad> it(m_highlightQuads);
|
|
while (it.hasNext()) {
|
|
it.next().transform(matrix);
|
|
}
|
|
}
|
|
|
|
void HighlightAnnotationPrivate::baseTransform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::baseTransform(matrix);
|
|
|
|
QMutableListIterator<HighlightAnnotation::Quad> it(m_highlightQuads);
|
|
while (it.hasNext()) {
|
|
it.next().transform(matrix);
|
|
}
|
|
}
|
|
|
|
void HighlightAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
m_highlightQuads.clear();
|
|
|
|
// loop through the whole children looking for a 'hl' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("hl")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the attributes
|
|
if (e.hasAttribute(QStringLiteral("type"))) {
|
|
m_highlightType = (HighlightAnnotation::HighlightType)e.attribute(QStringLiteral("type")).toInt();
|
|
}
|
|
|
|
// parse all 'quad' subnodes
|
|
QDomNode quadNode = e.firstChild();
|
|
for (; quadNode.isElement(); quadNode = quadNode.nextSibling()) {
|
|
QDomElement qe = quadNode.toElement();
|
|
if (qe.tagName() != QLatin1String("quad")) {
|
|
continue;
|
|
}
|
|
|
|
HighlightAnnotation::Quad q;
|
|
q.setPoint(NormalizedPoint(qe.attribute(QStringLiteral("ax"), QStringLiteral("0.0")).toDouble(), qe.attribute(QStringLiteral("ay"), QStringLiteral("0.0")).toDouble()), 0);
|
|
q.setPoint(NormalizedPoint(qe.attribute(QStringLiteral("bx"), QStringLiteral("0.0")).toDouble(), qe.attribute(QStringLiteral("by"), QStringLiteral("0.0")).toDouble()), 1);
|
|
q.setPoint(NormalizedPoint(qe.attribute(QStringLiteral("cx"), QStringLiteral("0.0")).toDouble(), qe.attribute(QStringLiteral("cy"), QStringLiteral("0.0")).toDouble()), 2);
|
|
q.setPoint(NormalizedPoint(qe.attribute(QStringLiteral("dx"), QStringLiteral("0.0")).toDouble(), qe.attribute(QStringLiteral("dy"), QStringLiteral("0.0")).toDouble()), 3);
|
|
q.setCapStart(qe.hasAttribute(QStringLiteral("start")));
|
|
q.setCapEnd(qe.hasAttribute(QStringLiteral("end")));
|
|
q.setFeather(qe.attribute(QStringLiteral("feather"), QStringLiteral("0.1")).toDouble());
|
|
|
|
q.transform(QTransform());
|
|
|
|
m_highlightQuads.append(q);
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *HighlightAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new HighlightAnnotationPrivate();
|
|
}
|
|
|
|
double HighlightAnnotationPrivate::distanceSqr(double x, double y, double xScale, double yScale) const
|
|
{
|
|
NormalizedPoint point(x, y);
|
|
double outsideDistance = DBL_MAX;
|
|
for (const HighlightAnnotation::Quad &quad : m_highlightQuads) {
|
|
QList<NormalizedPoint> pathPoints;
|
|
|
|
// first, we check if the point is within the area described by the 4 quads
|
|
// this is the case, if the point is always on one side of each segments delimiting the polygon:
|
|
pathPoints << quad.transformedPoint(0);
|
|
int directionVote = 0;
|
|
for (int i = 1; i < 5; ++i) {
|
|
NormalizedPoint thisPoint = quad.transformedPoint(i % 4);
|
|
directionVote += (isLeftOfVector(pathPoints.back(), thisPoint, point)) ? 1 : -1;
|
|
pathPoints << thisPoint;
|
|
}
|
|
if (abs(directionVote) == 4) {
|
|
return 0;
|
|
}
|
|
|
|
// if that's not the case, we treat the outline as path and simply determine
|
|
// the distance from the path to the point
|
|
const double thisOutsideDistance = ::distanceSqr(x, y, xScale, yScale, pathPoints);
|
|
if (thisOutsideDistance < outsideDistance) {
|
|
outsideDistance = thisOutsideDistance;
|
|
}
|
|
}
|
|
|
|
return outsideDistance;
|
|
}
|
|
|
|
/** StampAnnotation [Annotation] */
|
|
|
|
class Okular::StampAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
StampAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, m_stampIconName(QStringLiteral("Draft"))
|
|
{
|
|
}
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
bool canBeResized() const override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
QString m_stampIconName;
|
|
};
|
|
|
|
StampAnnotation::StampAnnotation()
|
|
: Annotation(*new StampAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
StampAnnotation::StampAnnotation(const QDomNode &description)
|
|
: Annotation(*new StampAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
StampAnnotation::~StampAnnotation()
|
|
{
|
|
}
|
|
|
|
void StampAnnotation::setStampIconName(const QString &name)
|
|
{
|
|
Q_D(StampAnnotation);
|
|
d->m_stampIconName = name;
|
|
}
|
|
|
|
QString StampAnnotation::stampIconName() const
|
|
{
|
|
Q_D(const StampAnnotation);
|
|
return d->m_stampIconName;
|
|
}
|
|
|
|
Annotation::SubType StampAnnotation::subType() const
|
|
{
|
|
return AStamp;
|
|
}
|
|
|
|
void StampAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const StampAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [stamp] element
|
|
QDomElement stampElement = document.createElement(QStringLiteral("stamp"));
|
|
node.appendChild(stampElement);
|
|
|
|
// append the optional attributes
|
|
if (d->m_stampIconName != QLatin1String("Draft")) {
|
|
stampElement.setAttribute(QStringLiteral("icon"), d->m_stampIconName);
|
|
}
|
|
}
|
|
|
|
void StampAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'stamp' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("stamp")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the attributes
|
|
if (e.hasAttribute(QStringLiteral("icon"))) {
|
|
m_stampIconName = e.attribute(QStringLiteral("icon"));
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool StampAnnotationPrivate::canBeResized() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
AnnotationPrivate *StampAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new StampAnnotationPrivate();
|
|
}
|
|
|
|
/** InkAnnotation [Annotation] */
|
|
|
|
class Okular::InkAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
InkAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
{
|
|
}
|
|
|
|
void transform(const QTransform &matrix) override;
|
|
void baseTransform(const QTransform &matrix) override;
|
|
void resetTransformation() override;
|
|
double distanceSqr(double x, double y, double xScale, double yScale) const override;
|
|
void translate(const NormalizedPoint &coord) override;
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
QList<QList<NormalizedPoint>> m_inkPaths;
|
|
QList<QList<NormalizedPoint>> m_transformedInkPaths;
|
|
};
|
|
|
|
InkAnnotation::InkAnnotation()
|
|
: Annotation(*new InkAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
InkAnnotation::InkAnnotation(const QDomNode &description)
|
|
: Annotation(*new InkAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
InkAnnotation::~InkAnnotation()
|
|
{
|
|
}
|
|
|
|
void InkAnnotation::setInkPaths(const QList<QList<NormalizedPoint>> &paths)
|
|
{
|
|
Q_D(InkAnnotation);
|
|
d->m_inkPaths = paths;
|
|
}
|
|
|
|
QList<QList<NormalizedPoint>> InkAnnotation::inkPaths() const
|
|
{
|
|
Q_D(const InkAnnotation);
|
|
return d->m_inkPaths;
|
|
}
|
|
|
|
QList<QList<NormalizedPoint>> InkAnnotation::transformedInkPaths() const
|
|
{
|
|
Q_D(const InkAnnotation);
|
|
return d->m_transformedInkPaths;
|
|
}
|
|
|
|
Annotation::SubType InkAnnotation::subType() const
|
|
{
|
|
return AInk;
|
|
}
|
|
|
|
void InkAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const InkAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [ink] element
|
|
QDomElement inkElement = document.createElement(QStringLiteral("ink"));
|
|
node.appendChild(inkElement);
|
|
|
|
// append the optional attributes
|
|
if (d->m_inkPaths.count() < 1) {
|
|
return;
|
|
}
|
|
|
|
QList<QList<NormalizedPoint>>::const_iterator pIt = d->m_inkPaths.begin(), pEnd = d->m_inkPaths.end();
|
|
for (; pIt != pEnd; ++pIt) {
|
|
QDomElement pathElement = document.createElement(QStringLiteral("path"));
|
|
inkElement.appendChild(pathElement);
|
|
const QList<NormalizedPoint> &path = *pIt;
|
|
for (const NormalizedPoint &point : path) {
|
|
QDomElement pointElement = document.createElement(QStringLiteral("point"));
|
|
pathElement.appendChild(pointElement);
|
|
pointElement.setAttribute(QStringLiteral("x"), QString::number(point.x));
|
|
pointElement.setAttribute(QStringLiteral("y"), QString::number(point.y));
|
|
}
|
|
}
|
|
}
|
|
|
|
double InkAnnotationPrivate::distanceSqr(double x, double y, double xScale, double yScale) const
|
|
{
|
|
double distance = DBL_MAX;
|
|
for (const QList<NormalizedPoint> &path : m_transformedInkPaths) {
|
|
const double thisDistance = ::distanceSqr(x, y, xScale, yScale, path);
|
|
if (thisDistance < distance) {
|
|
distance = thisDistance;
|
|
}
|
|
}
|
|
return strokeDistance(distance, m_style.width() * xScale / (m_page->m_width * 2));
|
|
}
|
|
|
|
void InkAnnotationPrivate::transform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::transform(matrix);
|
|
|
|
for (int i = 0; i < m_transformedInkPaths.count(); ++i) {
|
|
QMutableListIterator<NormalizedPoint> it(m_transformedInkPaths[i]);
|
|
while (it.hasNext()) {
|
|
it.next().transform(matrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InkAnnotationPrivate::baseTransform(const QTransform &matrix)
|
|
{
|
|
AnnotationPrivate::baseTransform(matrix);
|
|
|
|
for (int i = 0; i < m_inkPaths.count(); ++i) {
|
|
QMutableListIterator<NormalizedPoint> it(m_inkPaths[i]);
|
|
while (it.hasNext()) {
|
|
it.next().transform(matrix);
|
|
}
|
|
}
|
|
}
|
|
|
|
void InkAnnotationPrivate::resetTransformation()
|
|
{
|
|
AnnotationPrivate::resetTransformation();
|
|
|
|
m_transformedInkPaths = m_inkPaths;
|
|
}
|
|
|
|
void InkAnnotationPrivate::translate(const NormalizedPoint &coord)
|
|
{
|
|
AnnotationPrivate::translate(coord);
|
|
|
|
for (int i = 0; i < m_inkPaths.count(); ++i) {
|
|
QMutableListIterator<NormalizedPoint> it(m_inkPaths[i]);
|
|
while (it.hasNext()) {
|
|
NormalizedPoint &p = it.next();
|
|
p.x = p.x + coord.x;
|
|
p.y = p.y + coord.y;
|
|
}
|
|
}
|
|
}
|
|
|
|
void InkAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
m_inkPaths.clear();
|
|
|
|
// loop through the whole children looking for a 'ink' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("ink")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the 'path' subnodes
|
|
QDomNode pathNode = e.firstChild();
|
|
while (pathNode.isElement()) {
|
|
QDomElement pathElement = pathNode.toElement();
|
|
pathNode = pathNode.nextSibling();
|
|
|
|
if (pathElement.tagName() != QLatin1String("path")) {
|
|
continue;
|
|
}
|
|
|
|
// build each path parsing 'point' subnodes
|
|
QList<NormalizedPoint> path;
|
|
QDomNode pointNode = pathElement.firstChild();
|
|
while (pointNode.isElement()) {
|
|
QDomElement pointElement = pointNode.toElement();
|
|
pointNode = pointNode.nextSibling();
|
|
|
|
if (pointElement.tagName() != QLatin1String("point")) {
|
|
continue;
|
|
}
|
|
|
|
NormalizedPoint p;
|
|
p.x = pointElement.attribute(QStringLiteral("x"), QStringLiteral("0.0")).toDouble();
|
|
p.y = pointElement.attribute(QStringLiteral("y"), QStringLiteral("0.0")).toDouble();
|
|
path.append(p);
|
|
}
|
|
|
|
// add the path to the path list if it contains at least 2 nodes
|
|
if (path.count() >= 2) {
|
|
m_inkPaths.append(path);
|
|
}
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
|
|
m_transformedInkPaths = m_inkPaths;
|
|
}
|
|
|
|
AnnotationPrivate *InkAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new InkAnnotationPrivate();
|
|
}
|
|
|
|
/** CaretAnnotation [Annotation] */
|
|
|
|
class Okular::CaretAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
CaretAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, m_symbol(CaretAnnotation::None)
|
|
{
|
|
}
|
|
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
CaretAnnotation::CaretSymbol m_symbol;
|
|
};
|
|
|
|
static QString caretSymbolToString(CaretAnnotation::CaretSymbol symbol)
|
|
{
|
|
switch (symbol) {
|
|
case CaretAnnotation::None:
|
|
return QStringLiteral("None");
|
|
case CaretAnnotation::P:
|
|
return QStringLiteral("P");
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
static CaretAnnotation::CaretSymbol caretSymbolFromString(const QString &symbol)
|
|
{
|
|
if (symbol == QLatin1String("None")) {
|
|
return CaretAnnotation::None;
|
|
} else if (symbol == QLatin1String("P")) {
|
|
return CaretAnnotation::P;
|
|
}
|
|
return CaretAnnotation::None;
|
|
}
|
|
|
|
void CaretAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'caret' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("caret")) {
|
|
continue;
|
|
}
|
|
|
|
// parse the attributes
|
|
if (e.hasAttribute(QStringLiteral("symbol"))) {
|
|
m_symbol = caretSymbolFromString(e.attribute(QStringLiteral("symbol")));
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *CaretAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new CaretAnnotationPrivate();
|
|
}
|
|
|
|
CaretAnnotation::CaretAnnotation()
|
|
: Annotation(*new CaretAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
CaretAnnotation::CaretAnnotation(const QDomNode &description)
|
|
: Annotation(*new CaretAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
CaretAnnotation::~CaretAnnotation()
|
|
{
|
|
}
|
|
|
|
void CaretAnnotation::setCaretSymbol(CaretAnnotation::CaretSymbol symbol)
|
|
{
|
|
Q_D(CaretAnnotation);
|
|
d->m_symbol = symbol;
|
|
}
|
|
|
|
CaretAnnotation::CaretSymbol CaretAnnotation::caretSymbol() const
|
|
{
|
|
Q_D(const CaretAnnotation);
|
|
return d->m_symbol;
|
|
}
|
|
|
|
Annotation::SubType CaretAnnotation::subType() const
|
|
{
|
|
return ACaret;
|
|
}
|
|
|
|
void CaretAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
Q_D(const CaretAnnotation);
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [caret] element
|
|
QDomElement caretElement = document.createElement(QStringLiteral("caret"));
|
|
node.appendChild(caretElement);
|
|
|
|
// append the optional attributes
|
|
if (d->m_symbol != None) {
|
|
caretElement.setAttribute(QStringLiteral("symbol"), caretSymbolToString(d->m_symbol));
|
|
}
|
|
}
|
|
|
|
/** FileAttachmentAnnotation [Annotation] */
|
|
|
|
class Okular::FileAttachmentAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
FileAttachmentAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, icon(QStringLiteral("PushPin"))
|
|
, embfile(nullptr)
|
|
{
|
|
}
|
|
~FileAttachmentAnnotationPrivate() override
|
|
{
|
|
delete embfile;
|
|
}
|
|
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
// data fields
|
|
QString icon;
|
|
EmbeddedFile *embfile;
|
|
};
|
|
|
|
void FileAttachmentAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'fileattachment' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("fileattachment")) {
|
|
continue;
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *FileAttachmentAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new FileAttachmentAnnotationPrivate();
|
|
}
|
|
|
|
FileAttachmentAnnotation::FileAttachmentAnnotation()
|
|
: Annotation(*new FileAttachmentAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
FileAttachmentAnnotation::FileAttachmentAnnotation(const QDomNode &description)
|
|
: Annotation(*new FileAttachmentAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
FileAttachmentAnnotation::~FileAttachmentAnnotation()
|
|
{
|
|
}
|
|
|
|
void FileAttachmentAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [fileattachment] element
|
|
QDomElement fileAttachmentElement = document.createElement(QStringLiteral("fileattachment"));
|
|
node.appendChild(fileAttachmentElement);
|
|
}
|
|
|
|
Annotation::SubType FileAttachmentAnnotation::subType() const
|
|
{
|
|
return AFileAttachment;
|
|
}
|
|
|
|
QString FileAttachmentAnnotation::fileIconName() const
|
|
{
|
|
Q_D(const FileAttachmentAnnotation);
|
|
return d->icon;
|
|
}
|
|
|
|
void FileAttachmentAnnotation::setFileIconName(const QString &iconName)
|
|
{
|
|
Q_D(FileAttachmentAnnotation);
|
|
d->icon = iconName;
|
|
}
|
|
|
|
EmbeddedFile *FileAttachmentAnnotation::embeddedFile() const
|
|
{
|
|
Q_D(const FileAttachmentAnnotation);
|
|
return d->embfile;
|
|
}
|
|
|
|
void FileAttachmentAnnotation::setEmbeddedFile(EmbeddedFile *ef)
|
|
{
|
|
Q_D(FileAttachmentAnnotation);
|
|
d->embfile = ef;
|
|
}
|
|
|
|
/** SoundAnnotation [Annotation] */
|
|
|
|
class Okular::SoundAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
SoundAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, icon(QStringLiteral("Speaker"))
|
|
, sound(nullptr)
|
|
{
|
|
}
|
|
~SoundAnnotationPrivate() override
|
|
{
|
|
delete sound;
|
|
}
|
|
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
// data fields
|
|
QString icon;
|
|
Sound *sound;
|
|
};
|
|
|
|
void SoundAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'sound' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("sound")) {
|
|
continue;
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *SoundAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new SoundAnnotationPrivate();
|
|
}
|
|
|
|
SoundAnnotation::SoundAnnotation()
|
|
: Annotation(*new SoundAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
SoundAnnotation::SoundAnnotation(const QDomNode &description)
|
|
: Annotation(*new SoundAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
SoundAnnotation::~SoundAnnotation()
|
|
{
|
|
}
|
|
|
|
void SoundAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [sound] element
|
|
QDomElement soundElement = document.createElement(QStringLiteral("sound"));
|
|
node.appendChild(soundElement);
|
|
}
|
|
|
|
Annotation::SubType SoundAnnotation::subType() const
|
|
{
|
|
return ASound;
|
|
}
|
|
|
|
QString SoundAnnotation::soundIconName() const
|
|
{
|
|
Q_D(const SoundAnnotation);
|
|
return d->icon;
|
|
}
|
|
|
|
void SoundAnnotation::setSoundIconName(const QString &iconName)
|
|
{
|
|
Q_D(SoundAnnotation);
|
|
d->icon = iconName;
|
|
}
|
|
|
|
Sound *SoundAnnotation::sound() const
|
|
{
|
|
Q_D(const SoundAnnotation);
|
|
return d->sound;
|
|
}
|
|
|
|
void SoundAnnotation::setSound(Sound *s)
|
|
{
|
|
Q_D(SoundAnnotation);
|
|
d->sound = s;
|
|
}
|
|
|
|
/** MovieAnnotation [Annotation] */
|
|
|
|
class Okular::MovieAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
MovieAnnotationPrivate()
|
|
: AnnotationPrivate()
|
|
, movie(nullptr)
|
|
{
|
|
}
|
|
~MovieAnnotationPrivate() override
|
|
{
|
|
delete movie;
|
|
}
|
|
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
// data fields
|
|
Movie *movie;
|
|
};
|
|
|
|
void MovieAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'movie' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("movie")) {
|
|
continue;
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *MovieAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new MovieAnnotationPrivate();
|
|
}
|
|
|
|
MovieAnnotation::MovieAnnotation()
|
|
: Annotation(*new MovieAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
MovieAnnotation::MovieAnnotation(const QDomNode &description)
|
|
: Annotation(*new MovieAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
MovieAnnotation::~MovieAnnotation()
|
|
{
|
|
}
|
|
|
|
void MovieAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [movie] element
|
|
QDomElement movieElement = document.createElement(QStringLiteral("movie"));
|
|
node.appendChild(movieElement);
|
|
}
|
|
|
|
Annotation::SubType MovieAnnotation::subType() const
|
|
{
|
|
return AMovie;
|
|
}
|
|
|
|
Movie *MovieAnnotation::movie() const
|
|
{
|
|
Q_D(const MovieAnnotation);
|
|
return d->movie;
|
|
}
|
|
|
|
void MovieAnnotation::setMovie(Movie *movie)
|
|
{
|
|
Q_D(MovieAnnotation);
|
|
d->movie = movie;
|
|
}
|
|
|
|
/** ScreenAnnotation [Annotation] */
|
|
|
|
class Okular::ScreenAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
ScreenAnnotationPrivate();
|
|
~ScreenAnnotationPrivate() override;
|
|
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
Okular::Action *m_action;
|
|
QMap<Okular::Annotation::AdditionalActionType, Okular::Action *> m_additionalActions;
|
|
};
|
|
|
|
ScreenAnnotationPrivate::ScreenAnnotationPrivate()
|
|
: m_action(nullptr)
|
|
{
|
|
}
|
|
|
|
ScreenAnnotationPrivate::~ScreenAnnotationPrivate()
|
|
{
|
|
delete m_action;
|
|
qDeleteAll(m_additionalActions);
|
|
}
|
|
|
|
void ScreenAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'screen' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("screen")) {
|
|
continue;
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *ScreenAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new ScreenAnnotationPrivate();
|
|
}
|
|
|
|
ScreenAnnotation::ScreenAnnotation()
|
|
: Annotation(*new ScreenAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
ScreenAnnotation::ScreenAnnotation(const QDomNode &description)
|
|
: Annotation(*new ScreenAnnotationPrivate(), description)
|
|
{
|
|
}
|
|
|
|
ScreenAnnotation::~ScreenAnnotation()
|
|
{
|
|
}
|
|
|
|
void ScreenAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [screen] element
|
|
QDomElement movieElement = document.createElement(QStringLiteral("screen"));
|
|
node.appendChild(movieElement);
|
|
}
|
|
|
|
Annotation::SubType ScreenAnnotation::subType() const
|
|
{
|
|
return AScreen;
|
|
}
|
|
|
|
void ScreenAnnotation::setAdditionalAction(AdditionalActionType type, Action *action)
|
|
{
|
|
Q_D(ScreenAnnotation);
|
|
if (d->m_additionalActions.contains(type)) {
|
|
delete d->m_additionalActions.value(type);
|
|
}
|
|
|
|
d->m_additionalActions.insert(type, action);
|
|
}
|
|
|
|
Action *ScreenAnnotation::additionalAction(AdditionalActionType type) const
|
|
{
|
|
Q_D(const ScreenAnnotation);
|
|
if (!d->m_additionalActions.contains(type)) {
|
|
return nullptr;
|
|
} else {
|
|
return d->m_additionalActions.value(type);
|
|
}
|
|
}
|
|
|
|
void ScreenAnnotation::setAction(Action *action)
|
|
{
|
|
Q_D(ScreenAnnotation);
|
|
|
|
delete d->m_action;
|
|
d->m_action = action;
|
|
}
|
|
|
|
Action *ScreenAnnotation::action() const
|
|
{
|
|
Q_D(const ScreenAnnotation);
|
|
return d->m_action;
|
|
}
|
|
|
|
/** WidgetAnnotation [Annotation] */
|
|
|
|
class Okular::WidgetAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
~WidgetAnnotationPrivate() override;
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
QMap<Okular::Annotation::AdditionalActionType, Okular::Action *> m_additionalActions;
|
|
};
|
|
|
|
WidgetAnnotationPrivate::~WidgetAnnotationPrivate()
|
|
{
|
|
qDeleteAll(m_additionalActions);
|
|
}
|
|
|
|
void WidgetAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'widget' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("widget")) {
|
|
continue;
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *WidgetAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new WidgetAnnotationPrivate();
|
|
}
|
|
|
|
WidgetAnnotation::WidgetAnnotation()
|
|
: Annotation(*new WidgetAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
WidgetAnnotation::WidgetAnnotation(const QDomNode &description)
|
|
: Annotation(*new WidgetAnnotationPrivate, description)
|
|
{
|
|
}
|
|
|
|
WidgetAnnotation::~WidgetAnnotation()
|
|
{
|
|
}
|
|
|
|
void WidgetAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [widget] element
|
|
QDomElement movieElement = document.createElement(QStringLiteral("widget"));
|
|
node.appendChild(movieElement);
|
|
}
|
|
|
|
Annotation::SubType WidgetAnnotation::subType() const
|
|
{
|
|
return AWidget;
|
|
}
|
|
|
|
void WidgetAnnotation::setAdditionalAction(AdditionalActionType type, Action *action)
|
|
{
|
|
Q_D(WidgetAnnotation);
|
|
if (d->m_additionalActions.contains(type)) {
|
|
delete d->m_additionalActions.value(type);
|
|
}
|
|
|
|
d->m_additionalActions.insert(type, action);
|
|
}
|
|
|
|
Action *WidgetAnnotation::additionalAction(AdditionalActionType type) const
|
|
{
|
|
Q_D(const WidgetAnnotation);
|
|
if (!d->m_additionalActions.contains(type)) {
|
|
return nullptr;
|
|
} else {
|
|
return d->m_additionalActions.value(type);
|
|
}
|
|
}
|
|
|
|
/** RichMediaAnnotation [Annotation] */
|
|
|
|
class Okular::RichMediaAnnotationPrivate : public Okular::AnnotationPrivate
|
|
{
|
|
public:
|
|
RichMediaAnnotationPrivate();
|
|
~RichMediaAnnotationPrivate() override;
|
|
void setAnnotationProperties(const QDomNode &node) override;
|
|
AnnotationPrivate *getNewAnnotationPrivate() override;
|
|
|
|
// data fields
|
|
Movie *movie;
|
|
EmbeddedFile *embeddedFile;
|
|
};
|
|
|
|
RichMediaAnnotationPrivate::RichMediaAnnotationPrivate()
|
|
: movie(nullptr)
|
|
, embeddedFile(nullptr)
|
|
{
|
|
}
|
|
|
|
RichMediaAnnotationPrivate::~RichMediaAnnotationPrivate()
|
|
{
|
|
delete movie;
|
|
delete embeddedFile;
|
|
}
|
|
|
|
void RichMediaAnnotationPrivate::setAnnotationProperties(const QDomNode &node)
|
|
{
|
|
Okular::AnnotationPrivate::setAnnotationProperties(node);
|
|
|
|
// loop through the whole children looking for a 'richMedia' element
|
|
QDomNode subNode = node.firstChild();
|
|
while (subNode.isElement()) {
|
|
QDomElement e = subNode.toElement();
|
|
subNode = subNode.nextSibling();
|
|
if (e.tagName() != QLatin1String("richMedia")) {
|
|
continue;
|
|
}
|
|
|
|
// loading complete
|
|
break;
|
|
}
|
|
}
|
|
|
|
AnnotationPrivate *RichMediaAnnotationPrivate::getNewAnnotationPrivate()
|
|
{
|
|
return new RichMediaAnnotationPrivate();
|
|
}
|
|
|
|
RichMediaAnnotation::RichMediaAnnotation()
|
|
: Annotation(*new RichMediaAnnotationPrivate())
|
|
{
|
|
}
|
|
|
|
RichMediaAnnotation::RichMediaAnnotation(const QDomNode &description)
|
|
: Annotation(*new RichMediaAnnotationPrivate, description)
|
|
{
|
|
}
|
|
|
|
RichMediaAnnotation::~RichMediaAnnotation()
|
|
{
|
|
}
|
|
|
|
void RichMediaAnnotation::store(QDomNode &node, QDomDocument &document) const
|
|
{
|
|
// recurse to parent objects storing properties
|
|
Annotation::store(node, document);
|
|
|
|
// create [richMedia] element
|
|
QDomElement movieElement = document.createElement(QStringLiteral("richMedia"));
|
|
node.appendChild(movieElement);
|
|
}
|
|
|
|
Annotation::SubType RichMediaAnnotation::subType() const
|
|
{
|
|
return ARichMedia;
|
|
}
|
|
|
|
void RichMediaAnnotation::setMovie(Movie *movie)
|
|
{
|
|
Q_D(RichMediaAnnotation);
|
|
|
|
delete d->movie;
|
|
d->movie = movie;
|
|
}
|
|
|
|
Movie *RichMediaAnnotation::movie() const
|
|
{
|
|
Q_D(const RichMediaAnnotation);
|
|
|
|
return d->movie;
|
|
}
|
|
|
|
EmbeddedFile *RichMediaAnnotation::embeddedFile() const
|
|
{
|
|
Q_D(const RichMediaAnnotation);
|
|
|
|
return d->embeddedFile;
|
|
}
|
|
|
|
void RichMediaAnnotation::setEmbeddedFile(EmbeddedFile *embeddedFile)
|
|
{
|
|
Q_D(RichMediaAnnotation);
|
|
|
|
delete d->embeddedFile;
|
|
d->embeddedFile = embeddedFile;
|
|
}
|