okular/core/action.cpp

/*
    SPDX-FileCopyrightText: 2004-2005 Enrico Ros <eros.kde@email.it>

    SPDX-License-Identifier: GPL-2.0-or-later
*/

#include "action.h"

// kde includes
#include <KLocalizedString>

// local includes
#include "document.h"
#include "movie.h"
#include "sound.h"
#include "sourcereference_p.h"

using namespace Okular;

class Okular::ActionPrivate
{
public:
    ActionPrivate()
    {
    }

    virtual ~ActionPrivate()
    {
        qDeleteAll(m_nextActions);
    }

    ActionPrivate(const ActionPrivate &) = delete;
    ActionPrivate &operator=(const ActionPrivate &) = delete;

    QVariant m_nativeId;
    QVector<Action *> m_nextActions;
};

Action::Action(ActionPrivate &dd)
    : d_ptr(&dd)
{
}

Action::~Action()
{
    delete d_ptr;
}

QString Action::actionTip() const
{
    return QLatin1String("");
}

void Action::setNativeId(const QVariant &id)
{
    Q_D(Action);
    d->m_nativeId = id;
}

QVariant Action::nativeId() const
{
    Q_D(const Action);
    return d->m_nativeId;
}

QVector<Action *> Action::nextActions() const
{
    Q_D(const Action);
    return d->m_nextActions;
}

void Action::setNextActions(const QVector<Action *> &actions)
{
    Q_D(Action);
    qDeleteAll(d->m_nextActions);
    d->m_nextActions = actions;
}

// GotoAction

class Okular::GotoActionPrivate : public Okular::ActionPrivate
{
public:
    GotoActionPrivate(const QString &fileName, const DocumentViewport &viewport)
        : ActionPrivate()
        , m_extFileName(fileName)
        , m_vp(viewport)
    {
    }

    GotoActionPrivate(const QString &fileName, const QString &namedDestination)
        : ActionPrivate()
        , m_extFileName(fileName)
        , m_dest(namedDestination)
    {
    }

    QString m_extFileName;
    DocumentViewport m_vp;
    QString m_dest;
};

GotoAction::GotoAction(const QString &fileName, const DocumentViewport &viewport)
    : Action(*new GotoActionPrivate(fileName, viewport))
{
}

GotoAction::GotoAction(const QString &fileName, const QString &namedDestination)
    : Action(*new GotoActionPrivate(fileName, namedDestination))
{
}

GotoAction::~GotoAction()
{
}

Action::ActionType GotoAction::actionType() const
{
    return Goto;
}

QString GotoAction::actionTip() const
{
    Q_D(const GotoAction);
    return d->m_extFileName.isEmpty() ? (d->m_vp.isValid() ? i18n("Go to page %1", d->m_vp.pageNumber + 1) : QLatin1String("")) : i18n("Open external file");
}

bool GotoAction::isExternal() const
{
    Q_D(const GotoAction);
    return !d->m_extFileName.isEmpty();
}

QString GotoAction::fileName() const
{
    Q_D(const GotoAction);
    return d->m_extFileName;
}

DocumentViewport GotoAction::destViewport() const
{
    Q_D(const GotoAction);
    return d->m_vp;
}

QString GotoAction::destinationName() const
{
    Q_D(const GotoAction);
    return d->m_dest;
}

// ExecuteAction

class Okular::ExecuteActionPrivate : public Okular::ActionPrivate
{
public:
    ExecuteActionPrivate(const QString &file, const QString &parameters)
        : ActionPrivate()
        , m_fileName(file)
        , m_parameters(parameters)
    {
    }

    QString m_fileName;
    QString m_parameters;
};

ExecuteAction::ExecuteAction(const QString &file, const QString &parameters)
    : Action(*new ExecuteActionPrivate(file, parameters))
{
}

ExecuteAction::~ExecuteAction()
{
}

Action::ActionType ExecuteAction::actionType() const
{
    return Execute;
}

QString ExecuteAction::actionTip() const
{
    Q_D(const Okular::ExecuteAction);
    return i18n("Execute '%1'...", d->m_fileName);
}

QString ExecuteAction::fileName() const
{
    Q_D(const Okular::ExecuteAction);
    return d->m_fileName;
}

QString ExecuteAction::parameters() const
{
    Q_D(const Okular::ExecuteAction);
    return d->m_parameters;
}

// BrowseAction

class Okular::BrowseActionPrivate : public Okular::ActionPrivate
{
public:
    explicit BrowseActionPrivate(const QUrl &url)
        : ActionPrivate()
        , m_url(url)
    {
    }

    QUrl m_url;
};

BrowseAction::BrowseAction(const QUrl &url)
    : Action(*new BrowseActionPrivate(url))
{
}

BrowseAction::~BrowseAction()
{
}

Action::ActionType BrowseAction::actionType() const
{
    return Browse;
}

QString BrowseAction::actionTip() const
{
    Q_D(const Okular::BrowseAction);
    QString source;
    int row = 0, col = 0;
    if (extractLilyPondSourceReference(d->m_url, &source, &row, &col)) {
        return sourceReferenceToolTip(source, row, col);
    }
    return d->m_url.toDisplayString();
}

QUrl BrowseAction::url() const
{
    Q_D(const Okular::BrowseAction);
    return d->m_url;
}

// DocumentAction

class Okular::DocumentActionPrivate : public Okular::ActionPrivate
{
public:
    explicit DocumentActionPrivate(enum DocumentAction::DocumentActionType documentActionType)
        : ActionPrivate()
        , m_type(documentActionType)
    {
    }

    DocumentAction::DocumentActionType m_type;
};

DocumentAction::DocumentAction(enum DocumentActionType documentActionType)
    : Action(*new DocumentActionPrivate(documentActionType))
{
}

DocumentAction::~DocumentAction()
{
}

DocumentAction::DocumentActionType DocumentAction::documentActionType() const
{
    Q_D(const Okular::DocumentAction);
    return d->m_type;
}

Action::ActionType DocumentAction::actionType() const
{
    return DocAction;
}

QString DocumentAction::actionTip() const
{
    Q_D(const Okular::DocumentAction);
    switch (d->m_type) {
    case PageFirst:
        return i18n("First Page");
    case PagePrev:
        return i18n("Previous Page");
    case PageNext:
        return i18n("Next Page");
    case PageLast:
        return i18n("Last Page");
    case HistoryBack:
        return i18n("Back");
    case HistoryForward:
        return i18n("Forward");
    case Quit:
        return i18n("Quit");
    case Presentation:
        return i18n("Start Presentation");
    case EndPresentation:
        return i18n("End Presentation");
    case Find:
        return i18n("Find...");
    case GoToPage:
        return i18n("Go To Page...");
    case Close:
    default:;
    }

    return QString();
}

// SoundAction

class Okular::SoundActionPrivate : public Okular::ActionPrivate
{
public:
    SoundActionPrivate(double volume, bool sync, bool repeat, bool mix, Okular::Sound *sound)
        : ActionPrivate()
        , m_volume(volume)
        , m_sync(sync)
        , m_repeat(repeat)
        , m_mix(mix)
        , m_sound(sound)
    {
    }

    ~SoundActionPrivate() override
    {
        delete m_sound;
    }

    double m_volume;
    bool m_sync : 1;
    bool m_repeat : 1;
    bool m_mix : 1;
    Okular::Sound *m_sound;
};

SoundAction::SoundAction(double volume, bool sync, bool repeat, bool mix, Okular::Sound *sound)
    : Action(*new SoundActionPrivate(volume, sync, repeat, mix, sound))
{
}

SoundAction::~SoundAction()
{
}

Action::ActionType SoundAction::actionType() const
{
    return Sound;
}

QString SoundAction::actionTip() const
{
    return i18n("Play sound...");
}

double SoundAction::volume() const
{
    Q_D(const Okular::SoundAction);
    return d->m_volume;
}

bool SoundAction::synchronous() const
{
    Q_D(const Okular::SoundAction);
    return d->m_sync;
}

bool SoundAction::repeat() const
{
    Q_D(const Okular::SoundAction);
    return d->m_repeat;
}

bool SoundAction::mix() const
{
    Q_D(const Okular::SoundAction);
    return d->m_mix;
}

Okular::Sound *SoundAction::sound() const
{
    Q_D(const Okular::SoundAction);
    return d->m_sound;
}

// ScriptAction

class Okular::ScriptActionPrivate : public Okular::ActionPrivate
{
public:
    ScriptActionPrivate(enum ScriptType type, const QString &script)
        : ActionPrivate()
        , m_scriptType(type)
        , m_script(script)
    {
    }

    ScriptType m_scriptType;
    QString m_script;
};

ScriptAction::ScriptAction(enum ScriptType type, const QString &script)
    : Action(*new ScriptActionPrivate(type, script))
{
}

ScriptAction::~ScriptAction()
{
}

Action::ActionType ScriptAction::actionType() const
{
    return Script;
}

QString ScriptAction::actionTip() const
{
    Q_D(const Okular::ScriptAction);
    switch (d->m_scriptType) {
    case JavaScript:
        return i18n("JavaScript Script");
    }

    return QString();
}

ScriptType ScriptAction::scriptType() const
{
    Q_D(const Okular::ScriptAction);
    return d->m_scriptType;
}

QString ScriptAction::script() const
{
    Q_D(const Okular::ScriptAction);
    return d->m_script;
}

// MovieAction

class Okular::MovieActionPrivate : public Okular::ActionPrivate
{
public:
    explicit MovieActionPrivate(MovieAction::OperationType operation)
        : ActionPrivate()
        , m_operation(operation)
        , m_annotation(nullptr)
    {
    }

    MovieAction::OperationType m_operation;
    MovieAnnotation *m_annotation;
};

MovieAction::MovieAction(OperationType operation)
    : Action(*new MovieActionPrivate(operation))
{
}

MovieAction::~MovieAction()
{
}

Action::ActionType MovieAction::actionType() const
{
    return Movie;
}

QString MovieAction::actionTip() const
{
    return i18n("Play movie...");
}

MovieAction::OperationType MovieAction::operation() const
{
    Q_D(const Okular::MovieAction);
    return d->m_operation;
}

void MovieAction::setAnnotation(MovieAnnotation *annotation)
{
    Q_D(Okular::MovieAction);
    d->m_annotation = annotation;
}

MovieAnnotation *MovieAction::annotation() const
{
    Q_D(const Okular::MovieAction);
    return d->m_annotation;
}

// RenditionAction

class Okular::RenditionActionPrivate : public Okular::ActionPrivate
{
public:
    RenditionActionPrivate(RenditionAction::OperationType operation, Okular::Movie *movie, enum ScriptType scriptType, const QString &script)
        : ActionPrivate()
        , m_operation(operation)
        , m_movie(movie)
        , m_scriptType(scriptType)
        , m_script(script)
        , m_annotation(nullptr)
    {
    }

    RenditionAction::OperationType m_operation;
    Okular::Movie *m_movie;
    ScriptType m_scriptType;
    QString m_script;
    ScreenAnnotation *m_annotation;
};

RenditionAction::RenditionAction(OperationType operation, Okular::Movie *movie, enum ScriptType scriptType, const QString &script)
    : Action(*new RenditionActionPrivate(operation, movie, scriptType, script))
{
}

RenditionAction::~RenditionAction()
{
}

Action::ActionType RenditionAction::actionType() const
{
    return Rendition;
}

QString RenditionAction::actionTip() const
{
    Q_D(const Okular::RenditionAction);

    switch (d->m_operation) {
    default:
    case None:
        switch (d->m_scriptType) {
        case JavaScript:
            return i18n("JavaScript Script");
        default:
            return QString();
        }
    case Play:
        return i18n("Play movie");
    case Stop:
        return i18n("Stop movie");
    case Pause:
        return i18n("Pause movie");
    case Resume:
        return i18n("Resume movie");
    }
}

RenditionAction::OperationType RenditionAction::operation() const
{
    Q_D(const Okular::RenditionAction);
    return d->m_operation;
}

Okular::Movie *RenditionAction::movie() const
{
    Q_D(const Okular::RenditionAction);
    return d->m_movie;
}

ScriptType RenditionAction::scriptType() const
{
    Q_D(const Okular::RenditionAction);
    return d->m_scriptType;
}

QString RenditionAction::script() const
{
    Q_D(const Okular::RenditionAction);
    return d->m_script;
}

void RenditionAction::setAnnotation(ScreenAnnotation *annotation)
{
    Q_D(Okular::RenditionAction);
    d->m_annotation = annotation;
}

ScreenAnnotation *RenditionAction::annotation() const
{
    Q_D(const Okular::RenditionAction);
    return d->m_annotation;
}

BackendOpaqueAction::BackendOpaqueAction()
    : Action(*new ActionPrivate())
{
}

Action::ActionType BackendOpaqueAction::actionType() const
{
    return BackendOpaque;
}