poppler-qt4.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-2009, Albert Astals Cid <aacid@kde.org>
 * Copyright (C) 2005, Stefan Kebekus <stefan.kebekus@math.uni-koeln.de>
 * Copyright (C) 2006-2009, Pino Toscano <pino@kde.org>
 * Copyright (C) 2009 Shawn Rutledge <shawn.t.rutledge@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 "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;

    class POPPLER_QT4_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_QT4_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 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_QT4_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_QT4_EXPORT EmbeddedFile {
    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)

        EmbeddedFileData *m_embeddedFile;
    };


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

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

        enum PageAction {
            Opening,   
            Closing    
        };

        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;

        QImage thumbnail() const;

        QString text(const QRectF &rect) const;
        
        enum SearchDirection { FromTop,        
                               NextResult,     
                               PreviousResult  
        };

        enum SearchMode { CaseSensitive,   
                          CaseInsensitive  
        };
        
        bool search(const QString &text, QRectF &rect, SearchDirection direction, SearchMode caseSensitive, Rotation rotate = Rotate0) const;
        

        QList<TextBox*> textList(Rotation rotate = Rotate0) 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<FormField*> formFields() const;

        double duration() const;
        
        QString label() const;
        
    private:
        Q_DISABLE_COPY(Page)

        Page(DocumentData *doc, int index);
        PageData *m_page;
    };

    class POPPLER_QT4_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        
        };
        Q_DECLARE_FLAGS( RenderHints, RenderHint )

        
        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 *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;

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

        bool isLocked() const;

        QDateTime date( const QString & data ) const;

        QString info( const QString & data ) const;

        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;

        Q_DECL_DEPRECATED double pdfVersion() const;

        void getPdfVersion(int *major, int *minor) const;
  
        QList<FontInfo> fonts() const;

        Q_DECL_DEPRECATED bool scanForFonts( int numPages, QList<FontInfo> *fontList ) const;

        FontIterator* newFontIterator( int startPage = 0 ) const;

        QByteArray fontData(const FontInfo &font) const;

        QList<EmbeddedFile*> embeddedFiles() const;

        bool hasEmbeddedFiles() const;
        
        QDomDocument *toc() 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;

        ~Document();
  
    private:
        Q_DISABLE_COPY(Document)

        DocumentData *m_doc;
        
        Document(DocumentData *dataA);
    };
    
    class BaseConverterPrivate;
    class PSConverterPrivate;
    class PDFConverterPrivate;
    class POPPLER_QT4_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_QT4_EXPORT PSConverter : public BaseConverter
    {
        friend class Document;
        public:
            enum PSOption {
                Printing = 0x00000001,              
                StrictMargins = 0x00000002,
                ForceRasterization = 0x00000004
            };
            Q_DECLARE_FLAGS( PSOptions, PSOption )

            
            ~PSConverter();

            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;

            bool convert();

        private:
            Q_DECLARE_PRIVATE(PSConverter)
            Q_DISABLE_COPY(PSConverter)

            PSConverter(DocumentData *document);
    };

    class POPPLER_QT4_EXPORT PDFConverter : public BaseConverter
    {
        friend class Document;
        public:
            enum PDFOption {
                WithChanges = 0x00000001        
            };
            Q_DECLARE_FLAGS( PDFOptions, PDFOption )

            
            virtual ~PDFConverter();

            void setPDFOptions(PDFOptions options);
            PDFOptions pdfOptions() const;

            bool convert();

        private:
            Q_DECLARE_PRIVATE(PDFConverter)
            Q_DISABLE_COPY(PDFConverter)

            PDFConverter(DocumentData *document);
    };

    POPPLER_QT4_EXPORT QDateTime convertDate( char *dateString );

    POPPLER_QT4_EXPORT bool isCmsAvailable();

    class SoundData;
    class POPPLER_QT4_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_QT4_EXPORT MovieObject {
    friend class Page;
    public:
        enum PlayMode {
            PlayOnce,         
            PlayOpen,         
            PlayRepeat,       
            PlayPalindrome    
        };

        ~MovieObject();

        QString url() const;

        QSize size() const;

        int rotation() const;

        bool showControls() const;

        PlayMode playMode() const;

    private:
        MovieObject( AnnotMovie *ann );
        
        Q_DISABLE_COPY(MovieObject)

        MovieData *m_movieData;
    };

}

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

---