mirror of
https://invent.kde.org/graphics/okular
synced 2024-09-29 20:54:45 +00:00
5b449e5fdf
Added keystroke, format, validate, calculate events for combo boxes. Also did some refactoring for recalculateForms method.
449 lines
8.6 KiB
C++
449 lines
8.6 KiB
C++
/*
|
|
SPDX-FileCopyrightText: 2007 Pino Toscano <pino@kde.org>
|
|
|
|
SPDX-License-Identifier: GPL-2.0-or-later
|
|
*/
|
|
|
|
#include "form.h"
|
|
#include "form_p.h"
|
|
|
|
// qt includes
|
|
#include <QVariant>
|
|
|
|
#include "action.h"
|
|
|
|
using namespace Okular;
|
|
|
|
FormFieldPrivate::FormFieldPrivate(FormField::FieldType type)
|
|
: m_type(type)
|
|
, m_activateAction(nullptr)
|
|
, q_ptr(nullptr)
|
|
{
|
|
}
|
|
|
|
FormFieldPrivate::~FormFieldPrivate()
|
|
{
|
|
delete m_activateAction;
|
|
qDeleteAll(m_additionalActions);
|
|
qDeleteAll(m_additionalAnnotActions);
|
|
}
|
|
|
|
void FormFieldPrivate::setDefault()
|
|
{
|
|
m_default = value();
|
|
}
|
|
|
|
FormField::FormField(FormFieldPrivate &dd)
|
|
: d_ptr(&dd)
|
|
{
|
|
d_ptr->q_ptr = this;
|
|
}
|
|
|
|
FormField::~FormField()
|
|
{
|
|
delete d_ptr;
|
|
}
|
|
|
|
FormField::FieldType FormField::type() const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_type;
|
|
}
|
|
|
|
bool FormField::isReadOnly() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void FormField::setReadOnly(bool)
|
|
{
|
|
}
|
|
|
|
bool FormField::isVisible() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void FormField::setVisible(bool)
|
|
{
|
|
}
|
|
|
|
bool FormField::isPrintable() const
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void FormField::setPrintable(bool)
|
|
{
|
|
}
|
|
|
|
void FormField::setValue(const QVariant &)
|
|
{
|
|
}
|
|
|
|
void FormField::setAppearanceValue(const QVariant &)
|
|
{
|
|
}
|
|
|
|
QVariant FormField::value() const
|
|
{
|
|
return QVariant(QString());
|
|
}
|
|
|
|
Action *FormField::activationAction() const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_activateAction;
|
|
}
|
|
|
|
void FormField::setActivationAction(Action *action)
|
|
{
|
|
Q_D(FormField);
|
|
delete d->m_activateAction;
|
|
d->m_activateAction = action;
|
|
}
|
|
|
|
Action *FormField::additionalAction(AdditionalActionType type) const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_additionalActions.value(type);
|
|
}
|
|
|
|
void FormField::setAdditionalAction(AdditionalActionType type, Action *action)
|
|
{
|
|
Q_D(FormField);
|
|
delete d->m_additionalActions.value(type);
|
|
d->m_additionalActions[type] = action;
|
|
}
|
|
|
|
Action *FormField::additionalAction(Annotation::AdditionalActionType type) const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_additionalAnnotActions.value(type);
|
|
}
|
|
|
|
void FormField::setAdditionalAction(Annotation::AdditionalActionType type, Action *action)
|
|
{
|
|
Q_D(FormField);
|
|
delete d->m_additionalAnnotActions.value(type);
|
|
d->m_additionalAnnotActions[type] = action;
|
|
}
|
|
|
|
QList<Action *> FormField::additionalActions() const
|
|
{
|
|
Q_D(const FormField);
|
|
// yes, calling values() is not great but it's a list of ~10 elements, we can live with that
|
|
return d->m_additionalAnnotActions.values() + d->m_additionalActions.values(); // clazy:exclude=container-anti-pattern
|
|
}
|
|
|
|
Page *FormField::page() const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_page;
|
|
}
|
|
|
|
QString FormField::committedValue() const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_committedValue;
|
|
}
|
|
|
|
void FormField::commitValue(const QString &value)
|
|
{
|
|
Q_D(FormField);
|
|
d->m_committedValue = value;
|
|
}
|
|
|
|
QString FormField::committedFormattedValue() const
|
|
{
|
|
Q_D(const FormField);
|
|
return d->m_committedFormattedValue;
|
|
}
|
|
|
|
void FormField::commitFormattedValue(const QString &value)
|
|
{
|
|
Q_D(FormField);
|
|
d->m_committedFormattedValue = value;
|
|
}
|
|
|
|
class Okular::FormFieldButtonPrivate : public Okular::FormFieldPrivate
|
|
{
|
|
public:
|
|
FormFieldButtonPrivate()
|
|
: FormFieldPrivate(FormField::FormButton)
|
|
{
|
|
}
|
|
|
|
Q_DECLARE_PUBLIC(FormFieldButton)
|
|
|
|
void setValue(const QString &v) override
|
|
{
|
|
Q_Q(FormFieldButton);
|
|
q->setState(QVariant(v).toBool());
|
|
}
|
|
|
|
QString value() const override
|
|
{
|
|
Q_Q(const FormFieldButton);
|
|
return QVariant::fromValue<bool>(q->state()).toString();
|
|
}
|
|
};
|
|
|
|
FormFieldButton::FormFieldButton()
|
|
: FormField(*new FormFieldButtonPrivate())
|
|
{
|
|
}
|
|
|
|
FormFieldButton::~FormFieldButton()
|
|
{
|
|
}
|
|
|
|
void FormFieldButton::setState(bool)
|
|
{
|
|
}
|
|
|
|
void FormFieldButton::setIcon(Okular::FormField *)
|
|
{
|
|
}
|
|
|
|
class Okular::FormFieldTextPrivate : public Okular::FormFieldPrivate
|
|
{
|
|
public:
|
|
FormFieldTextPrivate()
|
|
: FormFieldPrivate(FormField::FormText)
|
|
{
|
|
}
|
|
|
|
Q_DECLARE_PUBLIC(FormFieldText)
|
|
|
|
void setValue(const QString &v) override
|
|
{
|
|
Q_Q(FormFieldText);
|
|
q->setText(v);
|
|
}
|
|
|
|
QString value() const override
|
|
{
|
|
Q_Q(const FormFieldText);
|
|
return q->text();
|
|
}
|
|
};
|
|
|
|
FormFieldText::FormFieldText()
|
|
: FormField(*new FormFieldTextPrivate())
|
|
{
|
|
}
|
|
|
|
FormFieldText::~FormFieldText()
|
|
{
|
|
}
|
|
|
|
void FormFieldText::setText(const QString &)
|
|
{
|
|
}
|
|
|
|
bool FormFieldText::isPassword() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool FormFieldText::isRichText() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int FormFieldText::maximumLength() const
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
Qt::Alignment FormFieldText::textAlignment() const
|
|
{
|
|
return Qt::AlignVCenter | Qt::AlignLeft;
|
|
}
|
|
|
|
bool FormFieldText::canBeSpellChecked() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void FormFieldText::setValue(const QVariant &value)
|
|
{
|
|
setText(value.toString());
|
|
}
|
|
|
|
void FormFieldText::setAppearanceValue(const QVariant &value)
|
|
{
|
|
setAppearanceText(value.toString());
|
|
}
|
|
|
|
QVariant FormFieldText::value() const
|
|
{
|
|
return QVariant(text());
|
|
}
|
|
|
|
class Okular::FormFieldChoicePrivate : public Okular::FormFieldPrivate
|
|
{
|
|
public:
|
|
FormFieldChoicePrivate()
|
|
: FormFieldPrivate(FormField::FormChoice)
|
|
{
|
|
}
|
|
|
|
Q_DECLARE_PUBLIC(FormFieldChoice)
|
|
|
|
void setValue(const QString &v) override
|
|
{
|
|
Q_Q(FormFieldChoice);
|
|
const QStringList choices = v.split(QLatin1Char(';'), Qt::SkipEmptyParts);
|
|
QList<int> newchoices;
|
|
for (const QString &str : choices) {
|
|
bool ok = true;
|
|
int val = str.toInt(&ok);
|
|
if (ok) {
|
|
newchoices.append(val);
|
|
}
|
|
}
|
|
if (!newchoices.isEmpty()) {
|
|
q->setCurrentChoices(newchoices);
|
|
}
|
|
}
|
|
|
|
QString value() const override
|
|
{
|
|
Q_Q(const FormFieldChoice);
|
|
QList<int> choices = q->currentChoices();
|
|
std::sort(choices.begin(), choices.end());
|
|
QStringList list;
|
|
for (const int c : std::as_const(choices)) {
|
|
list.append(QString::number(c));
|
|
}
|
|
return list.join(QStringLiteral(";"));
|
|
}
|
|
|
|
QMap<QString, QString> exportValues;
|
|
};
|
|
|
|
FormFieldChoice::FormFieldChoice()
|
|
: FormField(*new FormFieldChoicePrivate())
|
|
{
|
|
}
|
|
|
|
FormFieldChoice::~FormFieldChoice()
|
|
{
|
|
}
|
|
|
|
bool FormFieldChoice::isEditable() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool FormFieldChoice::multiSelect() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void FormFieldChoice::setCurrentChoices(const QList<int> &)
|
|
{
|
|
}
|
|
|
|
QString FormFieldChoice::editChoice() const
|
|
{
|
|
return QString();
|
|
}
|
|
|
|
void FormFieldChoice::setEditChoice(const QString &)
|
|
{
|
|
}
|
|
|
|
Qt::Alignment FormFieldChoice::textAlignment() const
|
|
{
|
|
return Qt::AlignVCenter | Qt::AlignLeft;
|
|
}
|
|
|
|
bool FormFieldChoice::canBeSpellChecked() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void FormFieldChoice::setExportValues(const QMap<QString, QString> &values)
|
|
{
|
|
Q_D(FormFieldChoice);
|
|
d->exportValues = values;
|
|
}
|
|
|
|
QString FormFieldChoice::exportValueForChoice(const QString &choice) const
|
|
{
|
|
Q_D(const FormFieldChoice);
|
|
return d->exportValues.value(choice, choice);
|
|
}
|
|
|
|
void FormFieldChoice::setValue(const QVariant &value)
|
|
{
|
|
if (choiceType() == ComboBox) {
|
|
const QStringList availableChoices = choices();
|
|
const QString valueToSet = value.toString();
|
|
for (int i = 0; i < availableChoices.size(); i++) {
|
|
if (valueToSet == availableChoices[i]) {
|
|
const QList oneChoiceList = {i};
|
|
setCurrentChoices(oneChoiceList);
|
|
return; // We expect to set only one element for a combo box
|
|
}
|
|
}
|
|
// If the value to be set is not present in the available choices
|
|
setEditChoice(valueToSet);
|
|
} else {
|
|
// TODO what to set for ListBox.
|
|
}
|
|
}
|
|
|
|
QVariant FormFieldChoice::value() const
|
|
{
|
|
if (choiceType() == ComboBox) {
|
|
if (currentChoices().isEmpty()) {
|
|
return QVariant(editChoice());
|
|
}
|
|
return QVariant(choices().at(currentChoices().constFirst()));
|
|
} else {
|
|
// TODO what to return for ListBox. Temporarily return empty string.
|
|
return QVariant(QString());
|
|
}
|
|
}
|
|
|
|
void FormFieldChoice::setAppearanceValue(const QVariant &value)
|
|
{
|
|
if (choiceType() == ComboBox) {
|
|
setAppearanceChoiceText(value.toString());
|
|
}
|
|
}
|
|
|
|
class Okular::FormFieldSignaturePrivate : public Okular::FormFieldPrivate
|
|
{
|
|
public:
|
|
FormFieldSignaturePrivate()
|
|
: FormFieldPrivate(FormField::FormSignature)
|
|
{
|
|
}
|
|
|
|
Q_DECLARE_PUBLIC(FormFieldSignature)
|
|
|
|
void setValue(const QString &v) override
|
|
{
|
|
Q_UNUSED(v)
|
|
}
|
|
|
|
QString value() const override
|
|
{
|
|
return QString();
|
|
}
|
|
};
|
|
|
|
FormFieldSignature::FormFieldSignature()
|
|
: FormField(*new FormFieldSignaturePrivate())
|
|
{
|
|
}
|
|
|
|
FormFieldSignature::~FormFieldSignature()
|
|
{
|
|
}
|