poppler-qt6.h

/* poppler-qt.h: qt interface to poppler
 * Copyright (C) 2005, Net Integration Technologies, Inc.
 * Copyright (C) 2005, 2007, Brad Hards <bradh@frogmouth.net>
 * Copyright (C) 2005-2015, 2017-2022, Albert Astals Cid <aacid@kde.org>
 * Copyright (C) 2005, Stefan Kebekus <stefan.kebekus@math.uni-koeln.de>
 * Copyright (C) 2006-2011, Pino Toscano <pino@kde.org>
 * Copyright (C) 2009 Shawn Rutledge <shawn.t.rutledge@gmail.com>
 * Copyright (C) 2010 Suzuki Toshiya <mpsuzuki@hiroshima-u.ac.jp>
 * Copyright (C) 2010 Matthias Fauconneau <matthias.fauconneau@gmail.com>
 * Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com>
 * Copyright (C) 2011 Glad Deschrijver <glad.deschrijver@gmail.com>
 * Copyright (C) 2012, Guillermo A. Amaral B. <gamaral@kde.org>
 * Copyright (C) 2012, Fabio D'Urso <fabiodurso@hotmail.it>
 * Copyright (C) 2012, Tobias Koenig <tobias.koenig@kdab.com>
 * Copyright (C) 2012, 2014, 2015, 2018, 2019 Adam Reichold <adamreichold@myopera.com>
 * Copyright (C) 2012, 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
 * Copyright (C) 2013 Anthony Granger <grangeranthony@gmail.com>
 * Copyright (C) 2016 Jakub Alba <jakubalba@gmail.com>
 * Copyright (C) 2017, 2020, 2021 Oliver Sander <oliver.sander@tu-dresden.de>
 * Copyright (C) 2017, 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by the LiMux project of the city of Munich
 * Copyright (C) 2018, 2021 Nelson Benítez León <nbenitezl@gmail.com>
 * Copyright (C) 2019 Jan Grulich <jgrulich@redhat.com>
 * Copyright (C) 2019 Alexander Volkov <a.volkov@rusbitech.ru>
 * Copyright (C) 2020 Philipp Knechtges <philipp-dev@knechtges.com>
 * Copyright (C) 2020 Katarina Behrens <Katarina.Behrens@cib.de>
 * Copyright (C) 2020 Thorsten Behrens <Thorsten.Behrens@CIB.de>
 * Copyright (C) 2020, 2024 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by Technische Universität Dresden
 * Copyright (C) 2021 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>.
 * Copyright (C) 2021 Mahmoud Khalil <mahmoudkhalil11@gmail.com>
 * Copyright (C) 2021 Georgiy Sgibnev <georgiy@sgibnev.com>. Work sponsored by lab50.net.
 * Copyright (C) 2022 Martin <martinbts@gmx.net>
 * Copyright (C) 2023 Kevin Ottens <kevin.ottens@enioka.com>. Work sponsored by De Bortoli Wines
 * Copyright (C) 2024 Pratham Gandhi <ppg.1382@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#ifndef __POPPLER_QT_H__
#define __POPPLER_QT_H__
 
#include <functional>
#include <memory>
#include <vector>
 
#include "poppler-annotation.h"
#include "poppler-link.h"
#include "poppler-optcontent.h"
#include "poppler-page-transition.h"
#include "poppler-converter.h"
 
#include <QtCore/QByteArray>
#include <QtCore/QDateTime>
#include <QtCore/QIODevice>
#include <QtCore/QSet>
#include "poppler-export.h"
 
class EmbFile;
class Sound;
class AnnotMovie;

namespace Poppler {
 
class Document;
class DocumentData;
 
class PageData;
 
class FormField;
class FormFieldSignature;
 
class TextBoxData;
 
class PDFConverter;
class PSConverter;
 
struct OutlineItemData;

using PopplerDebugFunc = void (*)(const QString & /*message*/, const QVariant & /*closure*/);

POPPLER_QT6_EXPORT void setDebugErrorFunction(PopplerDebugFunc debugFunction, const QVariant &closure);

class POPPLER_QT6_EXPORT TextBox
{
    friend class Page;
 
public:
    TextBox(const QString &text, const QRectF &bBox);
    ~TextBox();

    QString text() const;

    QRectF boundingBox() const;

    TextBox *nextWord() const;

    QRectF charBoundingBox(int i) const;

    bool hasSpaceAfter() const;
 
private:
    Q_DISABLE_COPY(TextBox)
 
    TextBoxData *m_data;
};
 
class FontInfoData;
class POPPLER_QT6_EXPORT FontInfo
{
    friend class Document;
 
public:
    enum Type
    {
        unknown,
        Type1,
        Type1C,
        Type1COT,
        Type3,
        TrueType,
        TrueTypeOT,
        CIDType0,
        CIDType0C,
        CIDType0COT,
        CIDTrueType,
        CIDTrueTypeOT
    };


    FontInfo();

    explicit FontInfo(const FontInfoData &fid);

    FontInfo(const FontInfo &fi);

    ~FontInfo();

    QString name() const;

    QString substituteName() const;

    QString file() const;

    bool isEmbedded() const;

    bool isSubset() const;

    Type type() const;

    QString typeName() const;

    FontInfo &operator=(const FontInfo &fi);
 
private:
    FontInfoData *m_data;
};
 
class FontIteratorData;
class POPPLER_QT6_EXPORT FontIterator
{
    friend class Document;
    friend class DocumentData;
 
public:
    ~FontIterator();

    QList<FontInfo> next();

    bool hasNext() const;

    int currentPage() const;
 
private:
    Q_DISABLE_COPY(FontIterator)
    FontIterator(int, DocumentData *dd);
 
    FontIteratorData *d;
};
 
class EmbeddedFileData;
class POPPLER_QT6_EXPORT EmbeddedFile
{
    friend class DocumentData;
    friend class AnnotationPrivate;
 
public:
    explicit EmbeddedFile(EmbFile *embfile);

    ~EmbeddedFile();

    QString name() const;

    QString description() const;

    int size() const;

    QDateTime modDate() const;

    QDateTime createDate() const;

    QByteArray checksum() const;

    QString mimeType() const;

    QByteArray data();

    bool isValid() const;

    // QDataStream dataStream() const;
 
private:
    Q_DISABLE_COPY(EmbeddedFile)
    explicit EmbeddedFile(EmbeddedFileData &dd);
 
    EmbeddedFileData *m_embeddedFile;
};

class POPPLER_QT6_EXPORT Page
{
    friend class Document;
 
public:
    ~Page();

    enum Rotation
    {
        Rotate0 = 0, 
        Rotate90 = 1, 
        Rotate180 = 2, 
        Rotate270 = 3 
    };

    enum PageAction
    {
        Opening, 
        Closing 
    };

    enum TextLayout
    {
        PhysicalLayout, 
        RawOrderLayout, 
        ReadingOrder, 
    };

    enum PainterFlag
    {
        NoPainterFlags = 0x00000000,
        DontSaveAndRestore = 0x00000001
    };
    Q_DECLARE_FLAGS(PainterFlags, PainterFlag)
 
    
    QImage renderToImage(double xres = 72.0, double yres = 72.0, int x = -1, int y = -1, int w = -1, int h = -1, Rotation rotate = Rotate0) const;

    using RenderToImagePartialUpdateFunc = void (*)(const QImage & /*image*/, const QVariant & /*closure*/);

    using ShouldRenderToImagePartialQueryFunc = bool (*)(const QVariant & /*closure*/);

    QImage renderToImage(double xres, double yres, int x, int y, int w, int h, Rotation rotate, RenderToImagePartialUpdateFunc partialUpdateCallback, ShouldRenderToImagePartialQueryFunc shouldDoPartialUpdateCallback,
                         const QVariant &payload) const;

    using ShouldAbortQueryFunc = bool (*)(const QVariant & /*closure*/);

    QImage renderToImage(double xres, double yres, int x, int y, int w, int h, Rotation rotate, RenderToImagePartialUpdateFunc partialUpdateCallback, ShouldRenderToImagePartialQueryFunc shouldDoPartialUpdateCallback,
                         ShouldAbortQueryFunc shouldAbortRenderCallback, const QVariant &payload) const;

    bool renderToPainter(QPainter *painter, double xres = 72.0, double yres = 72.0, int x = -1, int y = -1, int w = -1, int h = -1, Rotation rotate = Rotate0, PainterFlags flags = NoPainterFlags) const;

    QImage thumbnail() const;

    QString text(const QRectF &rect, TextLayout textLayout) const;

    QString text(const QRectF &rect) const;

    enum SearchDirection
    {
        FromTop, 
        NextResult, 
        PreviousResult 
    };

    enum SearchMode
    {
        CaseSensitive, 
        CaseInsensitive 
    };

    enum SearchFlag
    {
        NoSearchFlags = 0x00000000,
        IgnoreCase = 0x00000001, 
        WholeWords = 0x00000002, 
        IgnoreDiacritics = 0x00000004, 
        AcrossLines = 0x00000008 
    };
    Q_DECLARE_FLAGS(SearchFlags, SearchFlag)
 
    
    bool search(const QString &text, double &sLeft, double &sTop, double &sRight, double &sBottom, SearchDirection direction, SearchFlags flags = NoSearchFlags, Rotation rotate = Rotate0) const;

    QList<QRectF> search(const QString &text, SearchFlags flags = NoSearchFlags, Rotation rotate = Rotate0) const;

    std::vector<std::unique_ptr<TextBox>> textList(Rotation rotate = Rotate0) const;

    std::vector<std::unique_ptr<TextBox>> textList(Rotation rotate, ShouldAbortQueryFunc shouldAbortExtractionCallback, const QVariant &closure) const;

    QSizeF pageSizeF() const;

    QSize pageSize() const;

    PageTransition *transition() const;

    std::unique_ptr<Link> action(PageAction act) const;

    enum Orientation
    {
        Landscape, 
        Portrait, 
        Seascape, 
        UpsideDown 
    };

    Orientation orientation() const;

    void defaultCTM(double *CTM, double dpiX, double dpiY, int rotate, bool upsideDown);

    std::vector<std::unique_ptr<Link>> links() const;

    std::vector<std::unique_ptr<Annotation>> annotations() const;

    std::vector<std::unique_ptr<Annotation>> annotations(const QSet<Annotation::SubType> &subtypes) const;

    void addAnnotation(const Annotation *ann);

    void removeAnnotation(const Annotation *ann);

    std::vector<std::unique_ptr<FormField>> formFields() const;

    double duration() const;

    QString label() const;

    int index() const;
 
private:
    Q_DISABLE_COPY(Page)
 
    Page(DocumentData *doc, int index);
    PageData *m_page;
};

class POPPLER_QT6_EXPORT OutlineItem
{
    friend class Document;
 
public:
    OutlineItem();
    ~OutlineItem();
 
    OutlineItem(const OutlineItem &other);
    OutlineItem &operator=(const OutlineItem &other);
 
    OutlineItem(OutlineItem &&other) noexcept;
    OutlineItem &operator=(OutlineItem &&other) noexcept;

    bool isNull() const;

    QString name() const;

    bool isOpen() const;

    QSharedPointer<const LinkDestination> destination() const;

    QString externalFileName() const;

    QString uri() const;

    bool hasChildren() const;

    QVector<OutlineItem> children() const;
 
private:
    explicit OutlineItem(OutlineItemData *data);
    OutlineItemData *m_data;
};

class POPPLER_QT6_EXPORT Document
{
    friend class Page;
    friend class DocumentData;
 
public:
    enum PageMode
    {
        UseNone, 
        UseOutlines, 
        UseThumbs, 
        FullScreen, 
        UseOC, 
        UseAttach 
    };

    enum PageLayout
    {
        NoLayout, 
        SinglePage, 
        OneColumn, 
        TwoColumnLeft, 
        TwoColumnRight, 
        TwoPageLeft, 
        TwoPageRight 
    };

    enum RenderBackend
    {
        SplashBackend, 
        QPainterBackend 
    };

    enum RenderHint
    {
        Antialiasing = 0x00000001, 
        TextAntialiasing = 0x00000002, 
        TextHinting = 0x00000004, 
        TextSlightHinting = 0x00000008, 
        OverprintPreview = 0x00000010, 
        ThinLineSolid = 0x00000020, 
        ThinLineShape = 0x00000040, 
        IgnorePaperColor = 0x00000080, 
        HideAnnotations = 0x00000100 
    };
    Q_DECLARE_FLAGS(RenderHints, RenderHint)
 
    
    enum FormType
    {
        NoForm, 
        AcroForm, 
        XfaForm 
    };

    void setColorDisplayProfile(void *outputProfileA);
    void setColorDisplayProfileName(const QString &name);
    void *colorRgbProfile() const;
    void *colorDisplayProfile() const;

    static std::unique_ptr<Document> load(const QString &filePath, const QByteArray &ownerPassword = QByteArray(), const QByteArray &userPassword = QByteArray());

    static std::unique_ptr<Document> load(QIODevice *device, const QByteArray &ownerPassword = QByteArray(), const QByteArray &userPassword = QByteArray());

    static std::unique_ptr<Document> loadFromData(const QByteArray &fileContents, const QByteArray &ownerPassword = QByteArray(), const QByteArray &userPassword = QByteArray());

    std::unique_ptr<Page> page(int index) const;

    std::unique_ptr<Page> page(const QString &label) const;

    int numPages() const;

    PageMode pageMode() const;

    PageLayout pageLayout() const;

    Qt::LayoutDirection textDirection() const;

    bool unlock(const QByteArray &ownerPassword, const QByteArray &userPassword);

    bool isLocked() const;

    QDateTime date(const QString &type) const;

    bool setDate(const QString &key, const QDateTime &val);

    QDateTime creationDate() const;

    bool setCreationDate(const QDateTime &val);

    QDateTime modificationDate() const;

    bool setModificationDate(const QDateTime &val);

    QString info(const QString &type) const;

    bool setInfo(const QString &key, const QString &val);

    QString title() const;

    bool setTitle(const QString &val);

    QString author() const;

    bool setAuthor(const QString &val);

    QString subject() const;

    bool setSubject(const QString &val);

    QString keywords() const;

    bool setKeywords(const QString &val);

    QString creator() const;

    bool setCreator(const QString &val);

    QString producer() const;

    bool setProducer(const QString &val);

    bool removeInfo();

    QStringList infoKeys() const;

    bool isEncrypted() const;

    bool isLinearized() const;

    bool okToPrint() const;

    bool okToPrintHighRes() const;

    bool okToChange() const;

    bool okToCopy() const;

    bool okToAddNotes() const;

    bool okToFillForm() const;

    bool okToCreateFormFields() const;

    bool okToExtractForAccessibility() const;

    bool okToAssemble() const;

    struct PdfVersion
    {
        int major;
        int minor;
    };

    PdfVersion getPdfVersion() const;

    QList<FontInfo> fonts() const;

    std::unique_ptr<FontIterator> newFontIterator(int startPage = 0) const;

    QByteArray fontData(const FontInfo &fi) const;

    QList<EmbeddedFile *> embeddedFiles() const;

    bool hasEmbeddedFiles() const;

    QVector<OutlineItem> outline() const;

    std::unique_ptr<LinkDestination> linkDestination(const QString &name);

    void setPaperColor(const QColor &color);
    QColor paperColor() const;

    void setRenderBackend(RenderBackend backend);
    RenderBackend renderBackend() const;

    static QSet<RenderBackend> availableRenderBackends();

    void setRenderHint(RenderHint hint, bool on = true);
    RenderHints renderHints() const;

    std::unique_ptr<PSConverter> psConverter() const;

    std::unique_ptr<PDFConverter> pdfConverter() const;

    QString metadata() const;

    bool hasOptionalContent() const;

    OptContentModel *optionalContentModel();

    void applyResetFormsLink(const LinkResetForm &link);

    QStringList scripts() const;

    enum DocumentAdditionalActionsType
    {
        CloseDocument, 
        SaveDocumentStart, 
        SaveDocumentFinish, 
        PrintDocumentStart, 
        PrintDocumentFinish, 
    };

    std::unique_ptr<Link> additionalAction(DocumentAdditionalActionsType type) const;

    bool getPdfId(QByteArray *permanentId, QByteArray *updateId) const;

    FormType formType() const;

    QVector<int> formCalculateOrder() const;

    std::vector<std::unique_ptr<FormFieldSignature>> signatures() const;

    bool xrefWasReconstructed() const;

    void setXRefReconstructedCallback(const std::function<void()> &callback);

    ~Document();
 
private:
    Q_DISABLE_COPY(Document)
 
    DocumentData *m_doc;
 
    explicit Document(DocumentData *dataA);
};

POPPLER_QT6_EXPORT QDateTime convertDate(const char *dateString);

POPPLER_QT6_EXPORT bool isCmsAvailable();

POPPLER_QT6_EXPORT bool isOverprintPreviewAvailable();
 
class SoundData;
class POPPLER_QT6_EXPORT SoundObject
{
public:
    enum SoundType
    {
        External, 
        Embedded 
    };

    enum SoundEncoding
    {
        Raw, 
        Signed, 
        muLaw, 
        ALaw 
    };

    explicit SoundObject(Sound *popplersound);
 
    ~SoundObject();

    SoundType soundType() const;

    QString url() const;

    QByteArray data() const;

    double samplingRate() const;

    int channels() const;

    int bitsPerSample() const;

    SoundEncoding soundEncoding() const;
 
private:
    Q_DISABLE_COPY(SoundObject)
 
    SoundData *m_soundData;
};
 
class MovieData;
class POPPLER_QT6_EXPORT MovieObject
{
    friend class AnnotationPrivate;
 
public:
    enum PlayMode
    {
        PlayOnce, 
        PlayOpen, 
        PlayRepeat, 
        PlayPalindrome 
    };
 
    ~MovieObject();

    QString url() const;

    QSize size() const;

    int rotation() const;

    bool showControls() const;

    PlayMode playMode() const;

    bool showPosterImage() const;

    QImage posterImage() const;
 
private:
    explicit MovieObject(AnnotMovie *ann);
 
    Q_DISABLE_COPY(MovieObject)
 
    MovieData *m_movieData;
};
 
}
 
Q_DECLARE_OPERATORS_FOR_FLAGS(Poppler::Page::PainterFlags)
Q_DECLARE_OPERATORS_FOR_FLAGS(Poppler::Page::SearchFlags)
Q_DECLARE_OPERATORS_FOR_FLAGS(Poppler::Document::RenderHints)
 
#endif