poppler-qt5.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-2019, 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 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 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>
 *
 * 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 "poppler-annotation.h"
#include "poppler-link.h"
#include "poppler-optcontent.h"
#include "poppler-page-transition.h"
 
#include <QtCore/QByteArray>
#include <QtCore/QDateTime>
#include <QtCore/QSet>
#include <QtXml/QDomDocument>
#include "poppler-export.h"
 
class EmbFile;
class Sound;
class AnnotMovie;
 
namespace Poppler {
 
    class Document;
    class DocumentData;
 
    class PageData;
 
    class FormField;
 
    class TextBoxData;
 
    class PDFConverter;
    class PSConverter;
 
    struct OutlineItemData;
 
    typedef void (*PopplerDebugFunc)(const QString & /*message*/, const QVariant & /*closure*/);
 
    POPPLER_QT5_EXPORT void setDebugErrorFunction(PopplerDebugFunc debugFunction, const QVariant &closure);
 
    class POPPLER_QT5_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_QT5_EXPORT FontInfo {
    friend class Document;
    public:
        enum Type {
                unknown,
                Type1,
                Type1C,
                Type1COT,
                Type3,
                TrueType,
                TrueTypeOT,
                CIDType0,
                CIDType0C,
                CIDType0COT,
                CIDTrueType,
                CIDTrueTypeOT
        };
        
 
        FontInfo();
        
        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_QT5_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_QT5_EXPORT EmbeddedFile {
        friend class DocumentData;
        friend class AnnotationPrivate;
    public:
        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)
        EmbeddedFile(EmbeddedFileData &dd);
 
        EmbeddedFileData *m_embeddedFile;
    };
 
 
    class POPPLER_QT5_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          
        };
 
        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;
 
        typedef void (*RenderToImagePartialUpdateFunc)(const QImage & /*image*/, const QVariant & /*closure*/);
 
        typedef bool (*ShouldRenderToImagePartialQueryFunc)(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;
 
        typedef bool (*ShouldAbortQueryFunc)(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    
        };
        Q_DECLARE_FLAGS( SearchFlags, SearchFlag )
        
        
        Q_DECL_DEPRECATED bool search(const QString &text, double &rectLeft, double &rectTop, double &rectRight, double &rectBottom, SearchDirection direction, SearchMode caseSensitive, Rotation rotate = Rotate0) const;
 
        bool search(const QString &text, double &sLeft, double &sTop, double &sRight, double &sBottom, SearchDirection direction, SearchFlags flags = NoSearchFlags, Rotation rotate = Rotate0) const;
 
        Q_DECL_DEPRECATED QList<QRectF> search(const QString &text, SearchMode caseSensitive, Rotation rotate = Rotate0) const;
 
        QList<QRectF> search(const QString &text, SearchFlags flags = NoSearchFlags, Rotation rotate = Rotate0) const;
 
        QList<TextBox*> textList(Rotation rotate = Rotate0) const;
 
        QList<TextBox*> textList(Rotation rotate, ShouldAbortQueryFunc shouldAbortExtractionCallback, const QVariant &closure) const;
 
        QSizeF pageSizeF() const;
 
        QSize pageSize() const;
 
        PageTransition *transition() const;
        
        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);
        
        QList<Link*> links() const;
        
        QList<Annotation*> annotations() const;
 
 
        QList<Annotation*> annotations(const QSet<Annotation::SubType> &subtypes) const;
 
        void addAnnotation( const Annotation *ann );
 
        void removeAnnotation( const Annotation *ann );
 
        QList<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_QT5_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:
      OutlineItem(OutlineItemData *data);
      OutlineItemData *m_data;
    };
 
    class POPPLER_QT5_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,   
            ArthurBackend   
        };
 
        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 Document *load(const QString & filePath,
                              const QByteArray &ownerPassword=QByteArray(),
                              const QByteArray &userPassword=QByteArray());
        
        static Document *load(QIODevice *device,
                              const QByteArray &ownerPassword=QByteArray(),
                              const QByteArray &userPassword=QByteArray());
 
        static Document *loadFromData(const QByteArray &fileContents,
                              const QByteArray &ownerPassword=QByteArray(),
                              const QByteArray &userPassword=QByteArray());
  
        Page *page(int index) const;
 
        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;
 
        void getPdfVersion(int *major, int *minor) const;
  
        QList<FontInfo> fonts() const;
 
        FontIterator* newFontIterator( int startPage = 0 ) const;
 
        QByteArray fontData(const FontInfo &fi) const;
 
        QList<EmbeddedFile*> embeddedFiles() const;
 
        bool hasEmbeddedFiles() const;
        
        QDomDocument *toc() const;
 
        QVector<OutlineItem> outline() const;
        
        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;
        
        PSConverter *psConverter() const;
        
        PDFConverter *pdfConverter() const;
        
        QString metadata() const;
 
        bool hasOptionalContent() const;
 
        OptContentModel *optionalContentModel();
 
        QStringList scripts() const;
 
        bool getPdfId(QByteArray *permanentId, QByteArray *updateId) const;
 
        FormType formType() const;
 
        QVector<int> formCalculateOrder() const;
 
        ~Document();
  
    private:
        Q_DISABLE_COPY(Document)
 
        DocumentData *m_doc;
        
        Document(DocumentData *dataA);
    };
    
    class BaseConverterPrivate;
    class PSConverterPrivate;
    class PDFConverterPrivate;
    class POPPLER_QT5_EXPORT BaseConverter
    {
        friend class Document;
        public:
            virtual ~BaseConverter();
 
            void setOutputFileName(const QString &outputFileName);
 
            void setOutputDevice(QIODevice *device);
 
            virtual bool convert() = 0;
            
            enum Error
            {
                NoError,
                FileLockedError,
                OpenOutputError,
                NotSupportedInputFileError
            };
            
            Error lastError() const;
 
        protected:
            BaseConverter(BaseConverterPrivate &dd);
            Q_DECLARE_PRIVATE(BaseConverter)
            BaseConverterPrivate *d_ptr;
 
        private:
            Q_DISABLE_COPY(BaseConverter)
    };
 
    class POPPLER_QT5_EXPORT PSConverter : public BaseConverter
    {
        friend class Document;
        public:
            enum PSOption {
                Printing = 0x00000001,              
                StrictMargins = 0x00000002,
                ForceRasterization = 0x00000004,
                PrintToEPS = 0x00000008,            
                HideAnnotations = 0x00000010        
            };
            Q_DECLARE_FLAGS( PSOptions, PSOption )
 
            
            ~PSConverter() override;
 
            void setPageList(const QList<int> &pageList);
 
            void setTitle(const QString &title);
 
            void setHDPI(double hDPI);
 
            void setVDPI(double vDPI);
 
            void setRotate(int rotate);
 
            void setPaperWidth(int paperWidth);
 
            void setPaperHeight(int paperHeight);
 
            void setRightMargin(int marginRight);
 
            void setBottomMargin(int marginBottom);
 
            void setLeftMargin(int marginLeft);
 
            void setTopMargin(int marginTop);
 
            void setStrictMargins(bool strictMargins);
 
            void setForceRasterize(bool forceRasterize);
 
            void setPSOptions(PSOptions options);
 
            PSOptions psOptions() const;
 
            void setPageConvertedCallback(void (* callback)(int page, void *payload), void *payload);
 
            bool convert() override;
 
        private:
            Q_DECLARE_PRIVATE(PSConverter)
            Q_DISABLE_COPY(PSConverter)
 
            PSConverter(DocumentData *document);
    };
 
    class POPPLER_QT5_EXPORT PDFConverter : public BaseConverter
    {
        friend class Document;
        public:
            enum PDFOption {
                WithChanges = 0x00000001        
            };
            Q_DECLARE_FLAGS( PDFOptions, PDFOption )
 
            
            ~PDFConverter() override;
 
            void setPDFOptions(PDFOptions options);
            PDFOptions pdfOptions() const;
 
            bool convert() override;
 
        private:
            Q_DECLARE_PRIVATE(PDFConverter)
            Q_DISABLE_COPY(PDFConverter)
 
            PDFConverter(DocumentData *document);
    };
 
    POPPLER_QT5_EXPORT Q_DECL_DEPRECATED QDateTime convertDate( char *dateString );
 
    POPPLER_QT5_EXPORT QDateTime convertDate( const char *dateString );
 
    POPPLER_QT5_EXPORT bool isCmsAvailable();
    
    POPPLER_QT5_EXPORT bool isOverprintPreviewAvailable();
 
    class SoundData;
    class POPPLER_QT5_EXPORT SoundObject {
    public:
        enum SoundType {
            External,     
            Embedded      
        };
 
        enum SoundEncoding {
            Raw,          
            Signed,       
            muLaw,        
            ALaw          
        };
 
        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_QT5_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:
        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)
Q_DECLARE_OPERATORS_FOR_FLAGS(Poppler::PDFConverter::PDFOptions)
Q_DECLARE_OPERATORS_FOR_FLAGS(Poppler::PSConverter::PSOptions)
 
#endif