diff --git a/YACReader/YACReader.pri b/YACReader/YACReader.pri index 285067df..328f75a4 100644 --- a/YACReader/YACReader.pri +++ b/YACReader/YACReader.pri @@ -5,8 +5,18 @@ INCLUDEPATH += $$PWD/../common \ $$PWD/../custom_widgets win32 { -INCLUDEPATH += $$PWD/../dependencies/poppler/include -LIBS += -L$$PWD/../dependencies/poppler/lib -lpoppler-qt4 -loleaut32 -lole32 +LIBS += -L$$PWD/../dependencies/poppler/lib -loleaut32 -lole32 + +isEqual(QT_MAJOR_VERSION, 5) { +LIBS += -lpoppler-qt5 +INCLUDEPATH += ../dependencies/poppler/include/qt5 +} +else +{ +LIBS += -lpoppler-qt4 +INCLUDEPATH += ../dependencies/poppler/include/qt4 +} + QMAKE_CXXFLAGS_RELEASE += /MP /Ob2 /Oi /Ot /GT /GL QMAKE_LFLAGS_RELEASE += /LTCG CONFIG -= embed_manifest_exe diff --git a/YACReaderLibrary/YACReaderLibrary.pro b/YACReaderLibrary/YACReaderLibrary.pro index 10129b29..805447ef 100644 --- a/YACReaderLibrary/YACReaderLibrary.pro +++ b/YACReaderLibrary/YACReaderLibrary.pro @@ -16,8 +16,19 @@ INCLUDEPATH += ../common \ DEFINES += SERVER_RELEASE NOMINMAX win32 { -INCLUDEPATH += ../dependencies/poppler/include -LIBS += -L../dependencies/poppler/lib -lpoppler-qt4 -loleaut32 -lole32 + +LIBS += -L../dependencies/poppler/lib -loleaut32 -lole32 + +isEqual(QT_MAJOR_VERSION, 5) { +LIBS += -lpoppler-qt5 +INCLUDEPATH += ../dependencies/poppler/include/qt5 +} +else +{ +LIBS += -lpoppler-qt4 +INCLUDEPATH += ../dependencies/poppler/include/qt4 +} + QMAKE_CXXFLAGS_RELEASE += /MP /Ob2 /Oi /Ot /GT /GL QMAKE_LFLAGS_RELEASE += /LTCG CONFIG -= embed_manifest_exe diff --git a/YACReaderLibrary/library_creator.cpp b/YACReaderLibrary/library_creator.cpp index 9eb3302c..e5630455 100644 --- a/YACReaderLibrary/library_creator.cpp +++ b/YACReaderLibrary/library_creator.cpp @@ -17,7 +17,11 @@ #include using namespace std; -#include "poppler-qt4.h" +#if QT_VERSION >= 0x050000 + #include "poppler-qt5.h" +#else + #include "poppler-qt4.h" +#endif //-------------------------------------------------------------------------------- LibraryCreator::LibraryCreator() diff --git a/common/comic.h b/common/comic.h index 38607036..2cb215e4 100644 --- a/common/comic.h +++ b/common/comic.h @@ -10,7 +10,11 @@ #include "bookmarks.h" -#include "poppler-qt4.h" +#if QT_VERSION >= 0x050000 + #include "poppler-qt5.h" +#else + #include "poppler-qt4.h" +#endif class ComicDB; //#define EXTENSIONS << "*.jpg" << "*.jpeg" << "*.png" << "*.gif" << "*.tiff" << "*.tif" << "*.bmp" Comic::getSupportedImageFormats() diff --git a/dependencies/poppler/bin/poppler-qt5.dll b/dependencies/poppler/bin/poppler-qt5.dll new file mode 100644 index 00000000..675d8ad1 Binary files /dev/null and b/dependencies/poppler/bin/poppler-qt5.dll differ diff --git a/dependencies/poppler/include/poppler-annotation-helper.h b/dependencies/poppler/include/qt4/poppler-annotation-helper.h similarity index 100% rename from dependencies/poppler/include/poppler-annotation-helper.h rename to dependencies/poppler/include/qt4/poppler-annotation-helper.h diff --git a/dependencies/poppler/include/poppler-annotation-private.h b/dependencies/poppler/include/qt4/poppler-annotation-private.h similarity index 100% rename from dependencies/poppler/include/poppler-annotation-private.h rename to dependencies/poppler/include/qt4/poppler-annotation-private.h diff --git a/dependencies/poppler/include/poppler-annotation.h b/dependencies/poppler/include/qt4/poppler-annotation.h similarity index 100% rename from dependencies/poppler/include/poppler-annotation.h rename to dependencies/poppler/include/qt4/poppler-annotation.h diff --git a/dependencies/poppler/include/poppler-converter-private.h b/dependencies/poppler/include/qt4/poppler-converter-private.h similarity index 100% rename from dependencies/poppler/include/poppler-converter-private.h rename to dependencies/poppler/include/qt4/poppler-converter-private.h diff --git a/dependencies/poppler/include/poppler-embeddedfile-private.h b/dependencies/poppler/include/qt4/poppler-embeddedfile-private.h similarity index 100% rename from dependencies/poppler/include/poppler-embeddedfile-private.h rename to dependencies/poppler/include/qt4/poppler-embeddedfile-private.h diff --git a/dependencies/poppler/include/poppler-export.h b/dependencies/poppler/include/qt4/poppler-export.h similarity index 100% rename from dependencies/poppler/include/poppler-export.h rename to dependencies/poppler/include/qt4/poppler-export.h diff --git a/dependencies/poppler/include/poppler-form.h b/dependencies/poppler/include/qt4/poppler-form.h similarity index 100% rename from dependencies/poppler/include/poppler-form.h rename to dependencies/poppler/include/qt4/poppler-form.h diff --git a/dependencies/poppler/include/poppler-link-extractor-private.h b/dependencies/poppler/include/qt4/poppler-link-extractor-private.h similarity index 100% rename from dependencies/poppler/include/poppler-link-extractor-private.h rename to dependencies/poppler/include/qt4/poppler-link-extractor-private.h diff --git a/dependencies/poppler/include/poppler-link.h b/dependencies/poppler/include/qt4/poppler-link.h similarity index 100% rename from dependencies/poppler/include/poppler-link.h rename to dependencies/poppler/include/qt4/poppler-link.h diff --git a/dependencies/poppler/include/poppler-media.h b/dependencies/poppler/include/qt4/poppler-media.h similarity index 100% rename from dependencies/poppler/include/poppler-media.h rename to dependencies/poppler/include/qt4/poppler-media.h diff --git a/dependencies/poppler/include/poppler-optcontent-private.h b/dependencies/poppler/include/qt4/poppler-optcontent-private.h similarity index 100% rename from dependencies/poppler/include/poppler-optcontent-private.h rename to dependencies/poppler/include/qt4/poppler-optcontent-private.h diff --git a/dependencies/poppler/include/poppler-optcontent.h b/dependencies/poppler/include/qt4/poppler-optcontent.h similarity index 100% rename from dependencies/poppler/include/poppler-optcontent.h rename to dependencies/poppler/include/qt4/poppler-optcontent.h diff --git a/dependencies/poppler/include/poppler-page-private.h b/dependencies/poppler/include/qt4/poppler-page-private.h similarity index 100% rename from dependencies/poppler/include/poppler-page-private.h rename to dependencies/poppler/include/qt4/poppler-page-private.h diff --git a/dependencies/poppler/include/poppler-page-transition-private.h b/dependencies/poppler/include/qt4/poppler-page-transition-private.h similarity index 100% rename from dependencies/poppler/include/poppler-page-transition-private.h rename to dependencies/poppler/include/qt4/poppler-page-transition-private.h diff --git a/dependencies/poppler/include/poppler-page-transition.h b/dependencies/poppler/include/qt4/poppler-page-transition.h similarity index 100% rename from dependencies/poppler/include/poppler-page-transition.h rename to dependencies/poppler/include/qt4/poppler-page-transition.h diff --git a/dependencies/poppler/include/poppler-private.h b/dependencies/poppler/include/qt4/poppler-private.h similarity index 100% rename from dependencies/poppler/include/poppler-private.h rename to dependencies/poppler/include/qt4/poppler-private.h diff --git a/dependencies/poppler/include/poppler-qiodeviceoutstream-private.h b/dependencies/poppler/include/qt4/poppler-qiodeviceoutstream-private.h similarity index 100% rename from dependencies/poppler/include/poppler-qiodeviceoutstream-private.h rename to dependencies/poppler/include/qt4/poppler-qiodeviceoutstream-private.h diff --git a/dependencies/poppler/include/poppler-qt4.h b/dependencies/poppler/include/qt4/poppler-qt4.h similarity index 100% rename from dependencies/poppler/include/poppler-qt4.h rename to dependencies/poppler/include/qt4/poppler-qt4.h diff --git a/dependencies/poppler/include/qt5/ArthurOutputDev.h b/dependencies/poppler/include/qt5/ArthurOutputDev.h new file mode 100644 index 00000000..9d5e8679 --- /dev/null +++ b/dependencies/poppler/include/qt5/ArthurOutputDev.h @@ -0,0 +1,170 @@ +//======================================================================== +// +// ArthurOutputDev.h +// +// Copyright 2003 Glyph & Cog, LLC +// +//======================================================================== + +//======================================================================== +// +// Modified under the Poppler project - http://poppler.freedesktop.org +// +// All changes made under the Poppler project to this file are licensed +// under GPL version 2 or later +// +// Copyright (C) 2005 Brad Hards +// Copyright (C) 2005 Albert Astals Cid +// Copyright (C) 2009, 2011 Carlos Garcia Campos +// Copyright (C) 2010 Pino Toscano +// Copyright (C) 2011 Andreas Hartmetz +// Copyright (C) 2013 Thomas Freitag +// +// To see a description of the changes please see the Changelog file that +// came with your tarball or type make ChangeLog if you are building from git +// +//======================================================================== + +#ifndef ARTHUROUTPUTDEV_H +#define ARTHUROUTPUTDEV_H + +#ifdef USE_GCC_PRAGMAS +#pragma interface +#endif + +#include "goo/gtypes.h" +#include "OutputDev.h" +#include "GfxState.h" + +#include + +class GfxState; +class GfxPath; +class Gfx8BitFont; +struct GfxRGB; + +class SplashFont; +class SplashFontEngine; +struct SplashGlyphBitmap; + +//------------------------------------------------------------------------ +// ArthurOutputDev - Qt 4 QPainter renderer +//------------------------------------------------------------------------ + +class ArthurOutputDev: public OutputDev { +public: + /** + * Describes how fonts are distorted (aka hinted) to fit the pixel grid. + * More hinting means sharper edges and less adherence to the true letter shapes. + */ + enum FontHinting { + NoHinting = 0, ///< Font shapes are left unchanged + SlightHinting, ///< Font shapes are distorted vertically only + FullHinting ///< Font shapes are distorted horizontally and vertically + }; + + // Constructor. + ArthurOutputDev(QPainter *painter ); + + // Destructor. + virtual ~ArthurOutputDev(); + + void setFontHinting(FontHinting hinting) { m_fontHinting = hinting; } + + //----- get info about output device + + // Does this device use upside-down coordinates? + // (Upside-down means (0,0) is the top left corner of the page.) + virtual GBool upsideDown() { return gTrue; } + + // Does this device use drawChar() or drawString()? + virtual GBool useDrawChar() { return gTrue; } + + // Does this device use beginType3Char/endType3Char? Otherwise, + // text in Type 3 fonts will be drawn with drawChar/drawString. + virtual GBool interpretType3Chars() { return gTrue; } + + //----- initialization and control + + // Start a page. + virtual void startPage(int pageNum, GfxState *state, XRef *xref); + + // End a page. + virtual void endPage(); + + //----- save/restore graphics state + virtual void saveState(GfxState *state); + virtual void restoreState(GfxState *state); + + //----- update graphics state + virtual void updateAll(GfxState *state); + virtual void updateCTM(GfxState *state, double m11, double m12, + double m21, double m22, double m31, double m32); + virtual void updateLineDash(GfxState *state); + virtual void updateFlatness(GfxState *state); + virtual void updateLineJoin(GfxState *state); + virtual void updateLineCap(GfxState *state); + virtual void updateMiterLimit(GfxState *state); + virtual void updateLineWidth(GfxState *state); + virtual void updateFillColor(GfxState *state); + virtual void updateStrokeColor(GfxState *state); + virtual void updateFillOpacity(GfxState *state); + virtual void updateStrokeOpacity(GfxState *state); + + //----- update text state + virtual void updateFont(GfxState *state); + + //----- path painting + virtual void stroke(GfxState *state); + virtual void fill(GfxState *state); + virtual void eoFill(GfxState *state); + + //----- path clipping + virtual void clip(GfxState *state); + virtual void eoClip(GfxState *state); + + //----- text drawing + // virtual void drawString(GfxState *state, GooString *s); + virtual void drawChar(GfxState *state, double x, double y, + double dx, double dy, + double originX, double originY, + CharCode code, int nBytes, Unicode *u, int uLen); + virtual GBool beginType3Char(GfxState *state, double x, double y, + double dx, double dy, + CharCode code, Unicode *u, int uLen); + virtual void endType3Char(GfxState *state); + virtual void endTextObject(GfxState *state); + + //----- image drawing + virtual void drawImageMask(GfxState *state, Object *ref, Stream *str, + int width, int height, GBool invert, + GBool interpolate, GBool inlineImg); + virtual void drawImage(GfxState *state, Object *ref, Stream *str, + int width, int height, GfxImageColorMap *colorMap, + GBool interpolate, int *maskColors, GBool inlineImg); + + //----- Type 3 font operators + virtual void type3D0(GfxState *state, double wx, double wy); + virtual void type3D1(GfxState *state, double wx, double wy, + double llx, double lly, double urx, double ury); + + //----- special access + + // Called to indicate that a new PDF document has been loaded. + void startDoc(XRef *xrefA); + + GBool isReverseVideo() { return gFalse; } + +private: + QPainter *m_painter; + FontHinting m_fontHinting; + QFont m_currentFont; + QPen m_currentPen; + QBrush m_currentBrush; + GBool m_needFontUpdate; // set when the font needs to be updated + SplashFontEngine *m_fontEngine; + SplashFont *m_font; // current font + XRef *xref; // xref table for current document +}; + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-annotation-helper.h b/dependencies/poppler/include/qt5/poppler-annotation-helper.h new file mode 100644 index 00000000..5f335c04 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-annotation-helper.h @@ -0,0 +1,198 @@ +/* poppler-annotation-helper.h: qt interface to poppler + * Copyright (C) 2006, 2008, Albert Astals Cid + * Copyright (C) 2008, Pino Toscano + * Copyright (C) 2012, Fabio D'Urso + * Adapting code from + * Copyright (C) 2004 by Enrico Ros + * + * 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. + */ + +#include + +#include + +class QColor; + +class AnnotColor; + +namespace Poppler { + +class XPDFReader +{ + public: + // find named symbol and parse it + static inline void lookupName( Dict *, char *, QString & dest ); + static inline void lookupString( Dict *, char *, QString & dest ); + static inline void lookupBool( Dict *, char *, bool & dest ); + static inline void lookupInt( Dict *, char *, int & dest ); + static inline void lookupNum( Dict *, char *, double & dest ); + static inline int lookupNumArray( Dict *, char *, double * dest, int len ); + static inline void lookupColor( Dict *, char *, QColor & color ); + static inline void lookupIntRef( Dict *, char *, int & dest ); + static inline void lookupDate( Dict *, char *, QDateTime & dest ); + // transform from user coords to normalized ones using the matrix M + static inline void transform( double * M, double x, double y, QPointF &res ); + static inline void invTransform( double * M, const QPointF &p, double &x, double &y ); +}; + +void XPDFReader::lookupName( Dict * dict, char * type, QString & dest ) +{ + Object nameObj; + dict->lookup( type, &nameObj ); + if ( nameObj.isNull() ) + return; + if ( nameObj.isName() ) + dest = nameObj.getName(); + else + qDebug() << type << " is not Name." << endl; + nameObj.free(); +} + +void XPDFReader::lookupString( Dict * dict, char * type, QString & dest ) +{ + Object stringObj; + dict->lookup( type, &stringObj ); + if ( stringObj.isNull() ) + return; + if ( stringObj.isString() ) + dest = stringObj.getString()->getCString(); + else + qDebug() << type << " is not String." << endl; + stringObj.free(); +} + +void XPDFReader::lookupBool( Dict * dict, char * type, bool & dest ) +{ + Object boolObj; + dict->lookup( type, &boolObj ); + if ( boolObj.isNull() ) + return; + if ( boolObj.isBool() ) + dest = boolObj.getBool() == gTrue; + else + qDebug() << type << " is not Bool." << endl; + boolObj.free(); +} + +void XPDFReader::lookupInt( Dict * dict, char * type, int & dest ) +{ + Object intObj; + dict->lookup( type, &intObj ); + if ( intObj.isNull() ) + return; + if ( intObj.isInt() ) + dest = intObj.getInt(); + else + qDebug() << type << " is not Int." << endl; + intObj.free(); +} + +void XPDFReader::lookupNum( Dict * dict, char * type, double & dest ) +{ + Object numObj; + dict->lookup( type, &numObj ); + if ( numObj.isNull() ) + return; + if ( numObj.isNum() ) + dest = numObj.getNum(); + else + qDebug() << type << " is not Num." << endl; + numObj.free(); +} + +int XPDFReader::lookupNumArray( Dict * dict, char * type, double * dest, int len ) +{ + Object arrObj; + dict->lookup( type, &arrObj ); + if ( arrObj.isNull() ) + return 0; + Object numObj; + if ( arrObj.isArray() ) + { + len = qMin( len, arrObj.arrayGetLength() ); + for ( int i = 0; i < len; i++ ) + { + dest[i] = arrObj.arrayGet( i, &numObj )->getNum(); + numObj.free(); + } + } + else + { + len = 0; + qDebug() << type << "is not Array." << endl; + } + arrObj.free(); + return len; +} + +void XPDFReader::lookupColor( Dict * dict, char * type, QColor & dest ) +{ + double c[3]; + if ( XPDFReader::lookupNumArray( dict, type, c, 3 ) == 3 ) + dest = QColor( (int)(c[0]*255.0), (int)(c[1]*255.0), (int)(c[2]*255.0)); +} + +void XPDFReader::lookupIntRef( Dict * dict, char * type, int & dest ) +{ + Object refObj; + dict->lookupNF( type, &refObj ); + if ( refObj.isNull() ) + return; + if ( refObj.isRef() ) + dest = refObj.getRefNum(); + else + qDebug() << type << " is not Ref." << endl; + refObj.free(); +} + +void XPDFReader::lookupDate( Dict * dict, char * type, QDateTime & dest ) +{ + Object dateObj; + dict->lookup( type, &dateObj ); + if ( dateObj.isNull() ) + return; + if ( dateObj.isString() ) + { + dest = convertDate( dateObj.getString()->getCString() ); + } + else + qDebug() << type << " is not Date" << endl; + dateObj.free(); +} + +void XPDFReader::transform( double * M, double x, double y, QPointF &res ) +{ + res.setX( M[0] * x + M[2] * y + M[4] ); + res.setY( M[1] * x + M[3] * y + M[5] ); +} + +void XPDFReader::invTransform( double * M, const QPointF &p, double &x, double &y ) +{ + const double det = M[0]*M[3] - M[1]*M[2]; + Q_ASSERT(det != 0); + + const double invM[4] = { M[3]/det, -M[1]/det, -M[2]/det, M[0]/det }; + const double xt = p.x() - M[4]; + const double yt = p.y() - M[5]; + + x = invM[0] * xt + invM[2] * yt; + y = invM[1] * xt + invM[3] * yt; +} + +QColor convertAnnotColor( AnnotColor *color ); +AnnotColor* convertQColor( const QColor &color ); + +} diff --git a/dependencies/poppler/include/qt5/poppler-annotation-private.h b/dependencies/poppler/include/qt5/poppler-annotation-private.h new file mode 100644 index 00000000..c755eb35 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-annotation-private.h @@ -0,0 +1,112 @@ +/* poppler-annotation-private.h: qt interface to poppler + * Copyright (C) 2007, Pino Toscano + * Copyright (C) 2012, Tobias Koenig + * Copyright (C) 2012, 2013 Fabio D'Urso + * Copyright (C) 2012, Albert Astals Cid + * + * 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_ANNOTATION_PRIVATE_H_ +#define _POPPLER_ANNOTATION_PRIVATE_H_ + +#include +#include +#include + +#include "poppler-annotation.h" + +#include + +class Annot; +class AnnotPath; +class Link; +class Page; +class PDFRectangle; + +namespace Poppler +{ +class DocumentData; + +class AnnotationPrivate : public QSharedData +{ + public: + AnnotationPrivate(); + virtual ~AnnotationPrivate(); + + void addRevision(Annotation *ann, Annotation::RevScope scope, Annotation::RevType type); + + /* Returns an Annotation of the right subclass whose d_ptr points to + * this AnnotationPrivate */ + virtual Annotation * makeAlias() = 0; + + /* properties: contents related */ + QString author; + QString contents; + QString uniqueName; + QDateTime modDate; // before or equal to currentDateTime() + QDateTime creationDate; // before or equal to modifyDate + + /* properties: look/interaction related */ + int flags; + QRectF boundary; + + /* style and popup */ + Annotation::Style style; + Annotation::Popup popup; + + /* revisions */ + Annotation::RevScope revisionScope; + Annotation::RevType revisionType; + QList revisions; + + /* After this call, the Annotation object will behave like a wrapper for + * the specified Annot object. All cached values are discarded */ + void tieToNativeAnnot(Annot *ann, ::Page *page, DocumentData *doc); + + /* Creates a new Annot object on the specified page, flushes current + * values to that object and ties this Annotation to that object */ + virtual Annot* createNativeAnnot(::Page *destPage, DocumentData *doc) = 0; + + /* Inited to 0 (i.e. untied annotation) */ + Annot *pdfAnnot; + ::Page *pdfPage; + DocumentData * parentDoc; + + /* The following helpers only work if pdfPage is set */ + void flushBaseAnnotationProperties(); + void fillNormalizationMTX(double MTX[6], int pageRotation) const; + void fillTransformationMTX(double MTX[6]) const; + QRectF fromPdfRectangle(const PDFRectangle &r) const; + PDFRectangle boundaryToPdfRectangle(const QRectF &r, int flags) const; + AnnotPath * toAnnotPath(const QLinkedList &l) const; + + /* Scan page for annotations, parentId=0 searches for root annotations */ + static QList findAnnotations(::Page *pdfPage, DocumentData *doc, int parentId = 0); + + /* Add given annotation to given page */ + static void addAnnotationToPage(::Page *pdfPage, DocumentData *doc, const Annotation * ann); + + /* Remove annotation from page and destroy ann */ + static void removeAnnotationFromPage(::Page *pdfPage, const Annotation * ann); + + Ref pdfObjectReference() const; + + Link* additionalAction( Annotation::AdditionalActionType type ) const; +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-annotation.h b/dependencies/poppler/include/qt5/poppler-annotation.h new file mode 100644 index 00000000..bbcb9de0 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-annotation.h @@ -0,0 +1,1030 @@ +/* poppler-annotation.h: qt interface to poppler + * Copyright (C) 2006-2008, 2012, 2013 Albert Astals Cid + * Copyright (C) 2006, 2008 Pino Toscano + * Copyright (C) 2007, Brad Hards + * Copyright (C) 2010, Philip Lorenz + * Copyright (C) 2012, Tobias Koenig + * Copyright (C) 2012, Guillermo A. Amaral B. + * Copyright (C) 2012, 2013 Fabio D'Urso + * Copyright (C) 2013, Anthony Granger + * Adapting code from + * Copyright (C) 2004 by Enrico Ros + * + * 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_ANNOTATION_H_ +#define _POPPLER_ANNOTATION_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "poppler-export.h" + +namespace Poppler { + +class Annotation; +class AnnotationPrivate; +class TextAnnotationPrivate; +class LineAnnotationPrivate; +class GeomAnnotationPrivate; +class HighlightAnnotationPrivate; +class StampAnnotationPrivate; +class InkAnnotationPrivate; +class LinkAnnotationPrivate; +class CaretAnnotationPrivate; +class FileAttachmentAnnotationPrivate; +class SoundAnnotationPrivate; +class MovieAnnotationPrivate; +class ScreenAnnotationPrivate; +class WidgetAnnotationPrivate; +class EmbeddedFile; +class Link; +class SoundObject; +class MovieObject; +class LinkRendition; +class Page; + +/** + * \short Helper class for (recursive) Annotation retrieval/storage. + * + */ +class POPPLER_QT5_EXPORT AnnotationUtils +{ + public: + /** + * Restore an Annotation (with revisions if needed) from the DOM + * element \p annElement. + * \returns a pointer to the complete Annotation or 0 if element is + * invalid. + */ + static Annotation * createAnnotation( const QDomElement & annElement ); + + /** + * Save the Annotation \p ann as a child of \p annElement taking + * care of saving all revisions if \p ann has any. + */ + static void storeAnnotation( const Annotation * ann, + QDomElement & annElement, QDomDocument & document ); + + /** + * Returns an element called \p name from the direct children of + * \p parentNode or a null element if not found. + */ + static QDomElement findChildElement( const QDomNode & parentNode, + const QString & name ); +}; + + +/** + * \short Annotation class holding properties shared by all annotations. + * + * An Annotation is an object (text note, highlight, sound, popup window, ..) + * contained by a Page in the document. + * + * \warning Different Annotation objects might point to the same annotation. + * + * \section annotCreation How to add annotations + * + * Create an Annotation object of the desired subclass (for example + * TextAnnotation) and set its properties: + * @code + * Poppler::TextAnnotation* myann = new Poppler::TextAnnotation(Poppler::TextAnnotation::InPlace); + * myann->setBoundary(QRectF(0.1, 0.1, 0.2, 0.2)); // normalized coordinates: (0,0) is top-left, (1,1) is bottom-right + * myann->setContents("Hello, world!"); + * @endcode + * \note Always set a boundary rectangle, or nothing will be shown! + * + * Obtain a pointer to the Page where you want to add the annotation (refer to + * \ref req for instructions) and add the annotation: + * @code + * Poppler::Page* mypage = ...; + * mypage->addAnnotation(myann); + * @endcode + * + * You can keep on editing the annotation after it has been added to the page: + * @code + * myann->setContents("World, hello!"); // Let's change text... + * myann->setAuthor("Your name here"); // ...and set an author too + * @endcode + * + * When you're done with editing the annotation, you must destroy the Annotation + * object: + * @code + * delete myann; + * @endcode + * + * Use the PDFConverter class to save the modified document. + * + * \section annotFixedRotation FixedRotation flag specifics + * + * According to the PDF specification, annotations whose + * Annotation::FixedRotation flag is set must always be shown in their original + * orientation, no matter what the current rendering rotation or the page's + * Page::orientation() values are. In comparison with regular annotations, such + * annotations should therefore be transformed by an extra rotation at rendering + * time to "undo" such context-related rotations, which is equal to + * -(rendering_rotation + page_orientation). The rotation pivot + * is the top-left corner of the boundary rectangle. + * + * In practice, %Poppler's \ref Page::renderToImage only "unrotates" the + * page orientation, and does not unrotate the rendering rotation. + * This ensures consistent renderings at different Page::Rotation values: + * annotations are always positioned as if they were being positioned at the + * default page orientation. + * + * Just like regular annotations, %Poppler Qt4 exposes normalized coordinates + * relative to the page's default orientation. However, behind the scenes, the + * coordinate system is different and %Poppler transparently transforms each + * shape. If you never call either Annotation::setFlags or + * Annotation::setBoundary, you don't need to worry about this; but if you do + * call them, then you need to adhere to the following rules: + * - Whenever you toggle the Annotation::FixedRotation flag, you must + * set again the boundary rectangle first, and then you must set + * again any other geometry-related property. + * - Whenever you modify the boundary rectangle of an annotation whose + * Annotation::FixedRotation flag is set, you must set again any other + * geometry-related property. + * + * These two rules are necessary to make %Poppler's transparent coordinate + * conversion work properly. + */ +class POPPLER_QT5_EXPORT Annotation +{ + friend class AnnotationUtils; + friend class LinkMovie; + friend class LinkRendition; + + public: + // enum definitions + /** + * Annotation subclasses + * + * \sa subType() + */ + // WARNING!!! oKular uses that very same values so if you change them notify the author! + enum SubType + { + AText = 1, ///< TextAnnotation + ALine = 2, ///< LineAnnotation + AGeom = 3, ///< GeomAnnotation + AHighlight = 4, ///< HighlightAnnotation + AStamp = 5, ///< StampAnnotation + AInk = 6, ///< InkAnnotation + ALink = 7, ///< LinkAnnotation + ACaret = 8, ///< CaretAnnotation + AFileAttachment = 9, ///< FileAttachmentAnnotation + ASound = 10, ///< SoundAnnotation + AMovie = 11, ///< MovieAnnotation + AScreen = 12, ///< ScreenAnnotation \since 0.20 + AWidget = 13, ///< WidgetAnnotation \since 0.22 + A_BASE = 0 + }; + + /** + * Annotation flags + * + * They can be OR'd together (e.g. Annotation::FixedRotation | Annotation::DenyPrint). + * + * \sa flags(), setFlags(int) + */ + // NOTE: Only flags that are known to work are documented + enum Flag + { + Hidden = 1, ///< Do not display or print the annotation + FixedSize = 2, + FixedRotation = 4, ///< Do not rotate the annotation according to page orientation and rendering rotation \warning Extra care is needed with this flag: see \ref annotFixedRotation + DenyPrint = 8, ///< Do not print the annotation + DenyWrite = 16, + DenyDelete = 32, + ToggleHidingOnMouse = 64, + External = 128 + }; + + enum LineStyle { Solid = 1, Dashed = 2, Beveled = 4, Inset = 8, Underline = 16 }; + enum LineEffect { NoEffect = 1, Cloudy = 2}; + enum RevScope { Root = 0 /** \since 0.20 */, Reply = 1, Group = 2, Delete = 4 }; + enum RevType { None = 1, Marked = 2, Unmarked = 4, Accepted = 8, Rejected = 16, Cancelled = 32, Completed = 64 }; + + /** + * Returns the author of the annotation. + */ + QString author() const; + /** + * Sets a new author for the annotation. + */ + void setAuthor( const QString &author ); + + QString contents() const; + void setContents( const QString &contents ); + + /** + * Returns the unique name (ID) of the annotation. + */ + QString uniqueName() const; + /** + * Sets a new unique name for the annotation. + * + * \note no check of the new uniqueName is done + */ + void setUniqueName( const QString &uniqueName ); + + QDateTime modificationDate() const; + void setModificationDate( const QDateTime &date ); + + QDateTime creationDate() const; + void setCreationDate( const QDateTime &date ); + + /** + * Returns this annotation's flags + * + * \sa Flag, setFlags(int) + */ + int flags() const; + /** + * Sets this annotation's flags + * + * \sa Flag, flags(), \ref annotFixedRotation + */ + void setFlags( int flags ); + + /** + * Returns this annotation's boundary rectangle in normalized coordinates + * + * \sa setBoundary(const QRectF&) + */ + QRectF boundary() const; + /** + * Sets this annotation's boundary rectangle + * + * The boundary rectangle is the smallest rectangle that contains the + * annotation. + * + * \warning This property is mandatory: you must always set this. + * + * \sa boundary(), \ref annotFixedRotation + */ + void setBoundary( const QRectF &boundary ); + + /** + * \short Container class for Annotation style information + * + * \since 0.20 + */ + class POPPLER_QT5_EXPORT Style + { + public: + Style(); + Style( const Style &other ); + Style& operator=( const Style &other ); + ~Style(); + + // appearance properties + QColor color() const; // black + void setColor(const QColor &color); + double opacity() const; // 1.0 + void setOpacity(double opacity); + + // pen properties + double width() const; // 1.0 + void setWidth(double width); + LineStyle lineStyle() const; // LineStyle::Solid + void setLineStyle(LineStyle style); + double xCorners() const; // 0.0 + void setXCorners(double radius); + double yCorners() const; // 0.0 + void setYCorners(double radius); + const QVector& dashArray() const; // [ 3 ] + void setDashArray(const QVector &array); + + // pen effects + LineEffect lineEffect() const; // LineEffect::NoEffect + void setLineEffect(LineEffect effect); + double effectIntensity() const; // 1.0 + void setEffectIntensity(double intens); + + private: + class Private; + QSharedDataPointer d; + }; + + /// \since 0.20 + Style style() const; + /// \since 0.20 + void setStyle( const Style& style ); + + /** + * \short Container class for Annotation pop-up window information + * + * \since 0.20 + */ + class POPPLER_QT5_EXPORT Popup + { + public: + Popup(); + Popup( const Popup &other ); + Popup& operator=( const Popup &other ); + ~Popup(); + + // window state (Hidden, FixedRotation, Deny* flags allowed) + int flags() const; // -1 (never initialized) -> 0 (if inited and shown) + void setFlags( int flags ); + + // geometric properties + QRectF geometry() const; // no default + void setGeometry( const QRectF &geom ); + + // window contens/override properties + QString title() const; // '' text in the titlebar (overrides author) + void setTitle( const QString &title ); + QString summary() const; // '' short description (displayed if not empty) + void setSummary( const QString &summary ); + QString text() const; // '' text for the window (overrides annot->contents) + void setText( const QString &text ); + + private: + class Private; + QSharedDataPointer d; + }; + + /// \since 0.20 + Popup popup() const; + /// \warning Currently does nothing \since 0.20 + void setPopup( const Popup& popup ); + + /// \since 0.20 + RevScope revisionScope() const; // Root + + /// \since 0.20 + RevType revisionType() const; // None + + /** + * Returns the revisions of this annotation + * + * \note The caller owns the returned annotations and they should + * be deleted when no longer required. + * + * \since 0.20 + */ + QList revisions() const; + + /** + * The type of the annotation. + */ + virtual SubType subType() const = 0; + + /** + * Destructor. + */ + virtual ~Annotation(); + + /** + * Describes the flags from an annotations 'AA' dictionary. + * + * This flag is used by the additionalAction() method for ScreenAnnotation + * and WidgetAnnotation. + * + * \since 0.22 + */ + enum AdditionalActionType + { + CursorEnteringAction, ///< Performed when the cursor enters the annotation's active area + CursorLeavingAction, ///< Performed when the cursor exists the annotation's active area + MousePressedAction, ///< Performed when the mouse button is pressed inside the annotation's active area + MouseReleasedAction, ///< Performed when the mouse button is released inside the annotation's active area + FocusInAction, ///< Performed when the annotation receives the input focus + FocusOutAction, ///< Performed when the annotation loses the input focus + PageOpeningAction, ///< Performed when the page containing the annotation is opened + PageClosingAction, ///< Performed when the page containing the annotation is closed + PageVisibleAction, ///< Performed when the page containing the annotation becomes visible + PageInvisibleAction ///< Performed when the page containing the annotation becomes invisible + }; + + protected: + /// \cond PRIVATE + Annotation( AnnotationPrivate &dd ); + Annotation( AnnotationPrivate &dd, const QDomNode &description ); + void storeBaseAnnotationProperties( QDomNode & parentNode, QDomDocument & document ) const; + Q_DECLARE_PRIVATE( Annotation ) + QExplicitlySharedDataPointer d_ptr; + /// \endcond + + private: + virtual void store( QDomNode & parentNode, QDomDocument & document ) const = 0; + Q_DISABLE_COPY( Annotation ) +}; + +/** + * \short Annotation containing text. + * + * A text annotation is an object showing some text directly on the page, or + * linked to the contents using an icon shown on a page. + */ +class POPPLER_QT5_EXPORT TextAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + // local enums + enum TextType { Linked, InPlace }; + enum InplaceIntent { Unknown, Callout, TypeWriter }; + + TextAnnotation( TextType type ); + virtual ~TextAnnotation(); + virtual SubType subType() const; + + /** + The type of text annotation represented by this object + */ + TextType textType() const; + + /** + The name of the icon for this text annotation. + + Standard names for text annotation icons are: + - Comment + - Help + - Insert + - Key + - NewParagraph + - Note (this is the default icon to use) + - Paragraph + */ + QString textIcon() const; + + /** + Set the name of the icon to use for this text annotation. + + \sa textIcon for the list of standard names + */ + void setTextIcon( const QString &icon ); + + QFont textFont() const; + void setTextFont( const QFont &font ); + + int inplaceAlign() const; + void setInplaceAlign( int align ); + + QPointF calloutPoint( int id ) const; + /// \since 0.20 + QVector calloutPoints() const; + /// \since 0.20 + void setCalloutPoints( const QVector &points ); + + InplaceIntent inplaceIntent() const; + void setInplaceIntent( InplaceIntent intent ); + + private: + TextAnnotation( const QDomNode &node ); + TextAnnotation( TextAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + void setTextType( TextType type ); + Q_DECLARE_PRIVATE( TextAnnotation ) + Q_DISABLE_COPY( TextAnnotation ) +}; + +/** + * \short Polygon/polyline annotation. + * + * This annotation represents a polygon (or polyline) to be drawn on a page. + */ +class POPPLER_QT5_EXPORT LineAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + // local enums + /// \since 0.20 + enum LineType { StraightLine, Polyline }; + enum TermStyle { Square, Circle, Diamond, OpenArrow, ClosedArrow, None, + Butt, ROpenArrow, RClosedArrow, Slash }; + enum LineIntent { Unknown, Arrow, Dimension, PolygonCloud }; + + /// \since 0.20 + LineAnnotation( LineType type ); + virtual ~LineAnnotation(); + virtual SubType subType() const; + + /// \since 0.20 + LineType lineType() const; + + QLinkedList linePoints() const; + void setLinePoints( const QLinkedList &points ); + + TermStyle lineStartStyle() const; + void setLineStartStyle( TermStyle style ); + + TermStyle lineEndStyle() const; + void setLineEndStyle( TermStyle style ); + + bool isLineClosed() const; + void setLineClosed( bool closed ); + + QColor lineInnerColor() const; + void setLineInnerColor( const QColor &color ); + + double lineLeadingForwardPoint() const; + void setLineLeadingForwardPoint( double point ); + + double lineLeadingBackPoint() const; + void setLineLeadingBackPoint( double point ); + + bool lineShowCaption() const; + void setLineShowCaption( bool show ); + + LineIntent lineIntent() const; + void setLineIntent( LineIntent intent ); + + private: + LineAnnotation( const QDomNode &node ); + LineAnnotation( LineAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + void setLineType( LineType type ); + Q_DECLARE_PRIVATE( LineAnnotation ) + Q_DISABLE_COPY( LineAnnotation ) +}; + +/** + * \short Geometric annotation. + * + * The geometric annotation represents a geometric figure, like a rectangle or + * an ellipse. + */ +class POPPLER_QT5_EXPORT GeomAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + GeomAnnotation(); + virtual ~GeomAnnotation(); + virtual SubType subType() const; + + // common enums + enum GeomType { InscribedSquare, InscribedCircle }; + + GeomType geomType() const; + void setGeomType( GeomType style ); + + QColor geomInnerColor() const; + void setGeomInnerColor( const QColor &color ); + + private: + GeomAnnotation( const QDomNode &node ); + GeomAnnotation( GeomAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( GeomAnnotation ) + Q_DISABLE_COPY( GeomAnnotation ) +}; + +/** + * \short Text highlight annotation. + * + * The higlight annotation represents some areas of text being "highlighted". + */ +class POPPLER_QT5_EXPORT HighlightAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + HighlightAnnotation(); + virtual ~HighlightAnnotation(); + virtual SubType subType() const; + + /** + The type of highlight + */ + enum HighlightType { Highlight, ///< highlighter pen style annotation + Squiggly, ///< jagged or squiggly underline + Underline, ///< straight line underline + StrikeOut ///< straight line through-line + }; + + /** + Structure corresponding to a QuadPoints array. This matches a + quadrilateral that describes the area around a word (or set of + words) that are to be highlighted. + */ + struct Quad + { + QPointF points[4]; // 8 valid coords + bool capStart; // false (vtx 1-4) [K] + bool capEnd; // false (vtx 2-3) [K] + double feather; // 0.1 (in range 0..1) [K] + }; + + /** + The type (style) of highlighting to use for this area + or these areas. + */ + HighlightType highlightType() const; + + /** + Set the type of highlighting to use for the given area + or areas. + */ + void setHighlightType( HighlightType type ); + + /** + The list of areas to highlight. + */ + QList< Quad > highlightQuads() const; + + /** + Set the areas to highlight. + */ + void setHighlightQuads( const QList< Quad > &quads ); + + private: + HighlightAnnotation( const QDomNode &node ); + HighlightAnnotation( HighlightAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( HighlightAnnotation ) + Q_DISABLE_COPY( HighlightAnnotation ) +}; + +/** + * \short Stamp annotation. + * + * A simple annotation drawing a stamp on a page. + */ +class POPPLER_QT5_EXPORT StampAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + StampAnnotation(); + virtual ~StampAnnotation(); + virtual SubType subType() const; + + /** + The name of the icon for this stamp annotation. + + Standard names for stamp annotation icons are: + - Approved + - AsIs + - Confidential + - Departmental + - Draft (this is the default icon type) + - Experimental + - Expired + - Final + - ForComment + - ForPublicRelease + - NotApproved + - NotForPublicRelease + - Sold + - TopSecret + */ + QString stampIconName() const; + + /** + Set the icon type for this stamp annotation. + + \sa stampIconName for the list of standard icon names + */ + void setStampIconName( const QString &name ); + + private: + StampAnnotation( const QDomNode &node ); + StampAnnotation( StampAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( StampAnnotation ) + Q_DISABLE_COPY( StampAnnotation ) +}; + +/** + * \short Ink Annotation. + * + * Annotation representing an ink path on a page. + */ +class POPPLER_QT5_EXPORT InkAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + InkAnnotation(); + virtual ~InkAnnotation(); + virtual SubType subType() const; + + QList< QLinkedList > inkPaths() const; + void setInkPaths( const QList< QLinkedList > &paths ); + + private: + InkAnnotation( const QDomNode &node ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + InkAnnotation(InkAnnotationPrivate &dd); + Q_DECLARE_PRIVATE( InkAnnotation ) + Q_DISABLE_COPY( InkAnnotation ) +}; + +class POPPLER_QT5_EXPORT LinkAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + virtual ~LinkAnnotation(); + virtual SubType subType() const; + + // local enums + enum HighlightMode { None, Invert, Outline, Push }; + + /** \since 0.20 */ + Link* linkDestination() const; + void setLinkDestination( Link *link ); + + HighlightMode linkHighlightMode() const; + void setLinkHighlightMode( HighlightMode mode ); + + QPointF linkRegionPoint( int id ) const; + void setLinkRegionPoint( int id, const QPointF &point ); + + private: + LinkAnnotation(); + LinkAnnotation( const QDomNode &node ); + LinkAnnotation( LinkAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( LinkAnnotation ) + Q_DISABLE_COPY( LinkAnnotation ) +}; + +/** + * \short Caret annotation. + * + * The caret annotation represents a symbol to indicate the presence of text. + */ +class POPPLER_QT5_EXPORT CaretAnnotation : public Annotation +{ + friend class AnnotationUtils; + friend class AnnotationPrivate; + + public: + CaretAnnotation(); + virtual ~CaretAnnotation(); + virtual SubType subType() const; + + /** + * The symbols for the caret annotation. + */ + enum CaretSymbol { None, P }; + + CaretSymbol caretSymbol() const; + void setCaretSymbol( CaretSymbol symbol ); + + private: + CaretAnnotation( const QDomNode &node ); + CaretAnnotation( CaretAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( CaretAnnotation ) + Q_DISABLE_COPY( CaretAnnotation ) +}; + +/** + * \short File attachment annotation. + * + * The file attachment annotation represents a file embedded in the document. + * + * \since 0.10 + */ +class POPPLER_QT5_EXPORT FileAttachmentAnnotation : public Annotation +{ + friend class AnnotationPrivate; + + public: + virtual ~FileAttachmentAnnotation(); + virtual SubType subType() const; + + /** + * Returns the name of the icon of this annotation. + */ + QString fileIconName() const; + /** + * Sets a new name for the icon of this annotation. + */ + void setFileIconName( const QString &icon ); + + /** + * Returns the EmbeddedFile of this annotation. + */ + EmbeddedFile* embeddedFile() const; + /** + * Sets a new EmbeddedFile for this annotation. + * + * \note FileAttachmentAnnotation takes ownership of the object + */ + void setEmbeddedFile( EmbeddedFile *ef ); + + private: + FileAttachmentAnnotation(); + FileAttachmentAnnotation( const QDomNode &node ); + FileAttachmentAnnotation( FileAttachmentAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( FileAttachmentAnnotation ) + Q_DISABLE_COPY( FileAttachmentAnnotation ) +}; + +/** + * \short Sound annotation. + * + * The sound annotation represents a sound to be played when activated. + * + * \since 0.10 + */ +class POPPLER_QT5_EXPORT SoundAnnotation : public Annotation +{ + friend class AnnotationPrivate; + + public: + virtual ~SoundAnnotation(); + virtual SubType subType() const; + + /** + * Returns the name of the icon of this annotation. + */ + QString soundIconName() const; + /** + * Sets a new name for the icon of this annotation. + */ + void setSoundIconName( const QString &icon ); + + /** + * Returns the SoundObject of this annotation. + */ + SoundObject* sound() const; + /** + * Sets a new SoundObject for this annotation. + * + * \note SoundAnnotation takes ownership of the object + */ + void setSound( SoundObject *ef ); + + private: + SoundAnnotation(); + SoundAnnotation( const QDomNode &node ); + SoundAnnotation( SoundAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( SoundAnnotation ) + Q_DISABLE_COPY( SoundAnnotation ) +}; + +/** + * \short Movie annotation. + * + * The movie annotation represents a movie to be played when activated. + * + * \since 0.10 + */ +class POPPLER_QT5_EXPORT MovieAnnotation : public Annotation +{ + friend class AnnotationPrivate; + + public: + virtual ~MovieAnnotation(); + virtual SubType subType() const; + + /** + * Returns the MovieObject of this annotation. + */ + MovieObject* movie() const; + /** + * Sets a new MovieObject for this annotation. + * + * \note MovieAnnotation takes ownership of the object + */ + void setMovie( MovieObject *movie ); + + /** + * Returns the title of the movie of this annotation. + */ + QString movieTitle() const; + /** + * Sets a new title for the movie of this annotation. + */ + void setMovieTitle( const QString &title ); + + private: + MovieAnnotation(); + MovieAnnotation( const QDomNode &node ); + MovieAnnotation( MovieAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; + Q_DECLARE_PRIVATE( MovieAnnotation ) + Q_DISABLE_COPY( MovieAnnotation ) +}; + +/** + * \short Screen annotation. + * + * The screen annotation represents a screen to be played when activated. + * + * \since 0.20 + */ +class POPPLER_QT5_EXPORT ScreenAnnotation : public Annotation +{ + friend class AnnotationPrivate; + + public: + virtual ~ScreenAnnotation(); + + virtual SubType subType() const; + + /** + * Returns the LinkRendition of this annotation. + */ + LinkRendition* action() const; + + /** + * Sets a new LinkRendition for this annotation. + * + * \note ScreenAnnotation takes ownership of the object + */ + void setAction( LinkRendition *action ); + + /** + * Returns the title of the screen of this annotation. + */ + QString screenTitle() const; + + /** + * Sets a new title for the screen of this annotation. + */ + void setScreenTitle( const QString &title ); + + /** + * Returns the additional action of the given @p type fo the annotation or + * @c 0 if no action has been defined. + * + * \since 0.22 + */ + Link* additionalAction( AdditionalActionType type ) const; + + private: + ScreenAnnotation(); + ScreenAnnotation( ScreenAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; // stub + Q_DECLARE_PRIVATE( ScreenAnnotation ) + Q_DISABLE_COPY( ScreenAnnotation ) +}; + +/** + * \short Widget annotation. + * + * The widget annotation represents a widget (form field) on a page. + * + * \note This class is just provided for consistency of the annotation API, + * use the FormField classes to get all the form-related information. + * + * \since 0.22 + */ +class POPPLER_QT5_EXPORT WidgetAnnotation : public Annotation +{ + friend class AnnotationPrivate; + + public: + virtual ~WidgetAnnotation(); + + virtual SubType subType() const; + + /** + * Returns the additional action of the given @p type fo the annotation or + * @c 0 if no action has been defined. + * + * \since 0.22 + */ + Link* additionalAction( AdditionalActionType type ) const; + + private: + WidgetAnnotation(); + WidgetAnnotation( WidgetAnnotationPrivate &dd ); + virtual void store( QDomNode &parentNode, QDomDocument &document ) const; // stub + Q_DECLARE_PRIVATE( WidgetAnnotation ) + Q_DISABLE_COPY( WidgetAnnotation ) +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-converter-private.h b/dependencies/poppler/include/qt5/poppler-converter-private.h new file mode 100644 index 00000000..1340d354 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-converter-private.h @@ -0,0 +1,49 @@ +/* poppler-converter-private.h: Qt interface to poppler + * Copyright (C) 2007, 2009, Albert Astals Cid + * Copyright (C) 2008, Pino Toscano + * + * 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_QT5_CONVERTER_PRIVATE_H +#define POPPLER_QT5_CONVERTER_PRIVATE_H + +#include + +class QIODevice; + +namespace Poppler { + +class DocumentData; + +class BaseConverterPrivate +{ + public: + BaseConverterPrivate(); + virtual ~BaseConverterPrivate(); + + QIODevice* openDevice(); + void closeDevice(); + + DocumentData *document; + QString outputFileName; + QIODevice *iodev; + bool ownIodev : 1; + BaseConverter::Error lastError; +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-embeddedfile-private.h b/dependencies/poppler/include/qt5/poppler-embeddedfile-private.h new file mode 100644 index 00000000..ff1388ec --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-embeddedfile-private.h @@ -0,0 +1,42 @@ +/* poppler-embeddedfile-private.h: Qt interface to poppler + * Copyright (C) 2005, 2008, 2009, 2012, Albert Astals Cid + * Copyright (C) 2005, Brad Hards + * Copyright (C) 2008, 2011, Pino Toscano + * + * 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_EMBEDDEDFILE_PRIVATE_H +#define POPPLER_EMBEDDEDFILE_PRIVATE_H + +class FileSpec; + +namespace Poppler +{ + +class EmbeddedFileData +{ +public: + EmbeddedFileData(FileSpec *fs); + ~EmbeddedFileData(); + + EmbFile *embFile() const; + + FileSpec *filespec; +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-export.h b/dependencies/poppler/include/qt5/poppler-export.h new file mode 100644 index 00000000..fdce95c7 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-export.h @@ -0,0 +1,17 @@ +/* +* This file is used to set the poppler_qt5_EXPORT macros right. +* This is needed for setting the visibility on windows, it will have no effect on other platforms. +*/ +#if defined(_WIN32) +# define LIB_EXPORT __declspec(dllexport) +# define LIB_IMPORT __declspec(dllimport) +#else +# define LIB_EXPORT +# define LIB_IMPORT +#endif + +#ifdef poppler_qt5_EXPORTS +# define POPPLER_QT5_EXPORT LIB_EXPORT +#else +# define POPPLER_QT5_EXPORT LIB_IMPORT +#endif diff --git a/dependencies/poppler/include/qt5/poppler-form.h b/dependencies/poppler/include/qt5/poppler-form.h new file mode 100644 index 00000000..3481ce7b --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-form.h @@ -0,0 +1,343 @@ +/* poppler-form.h: qt interface to poppler + * Copyright (C) 2007-2008, Pino Toscano + * Copyright (C) 2008, 2011, Albert Astals Cid + * Copyright (C) 2012, Adam Reichold + * + * 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_QT5_FORM_H_ +#define _POPPLER_QT5_FORM_H_ + +#include +#include +#include "poppler-export.h" + +class Page; +class FormWidget; +class FormWidgetButton; +class FormWidgetText; +class FormWidgetChoice; + +namespace Poppler { + + class DocumentData; + class Link; + + class FormFieldData; + /** + The base class representing a form field. + + \since 0.6 + */ + class POPPLER_QT5_EXPORT FormField { + public: + + /** + The different types of form field. + */ + enum FormType { + FormButton, ///< A button field. See \ref Poppler::FormFieldButton::ButtonType "ButtonType" + FormText, ///< A text field. See \ref Poppler::FormFieldText::TextType "TextType" + FormChoice, ///< A single choice field. See \ref Poppler::FormFieldChoice::ChoiceType "ChoiceType" + FormSignature ///< A signature field. + }; + + virtual ~FormField(); + + /** + The type of the field. + */ + virtual FormType type() const = 0; + + /** + \return The size of the field, in normalized coordinates, i.e. + [0..1] with regard to the dimensions (cropbox) of the page + */ + QRectF rect() const; + + /** + The ID of the field. + */ + int id() const; + + /** + The internal name of the field. + */ + QString name() const; + + /** + The internal fully qualified name of the field. + \since 0.18 + */ + QString fullyQualifiedName() const; + + /** + The name of the field to be used in user interface (eg messages to + the user). + */ + QString uiName() const; + + /** + Whether this form field is read-only. + */ + bool isReadOnly() const; + + /** + Whether this form field is visible. + */ + bool isVisible() const; + + /** + The activation action of this form field. + + \note It may be null. + */ + Link* activationAction() const; + + protected: + /// \cond PRIVATE + FormField(FormFieldData &dd); + + FormFieldData *m_formData; + /// \endcond + + private: + Q_DISABLE_COPY(FormField) + }; + + /** + A form field that represents a "button". + + \since 0.8 + */ + class POPPLER_QT5_EXPORT FormFieldButton : public FormField { + public: + + /** + * The types of button field. + */ + enum ButtonType + { + Push, ///< A simple push button. + CheckBox, ///< A check box. + Radio ///< A radio button. + }; + + /// \cond PRIVATE + FormFieldButton(DocumentData *doc, ::Page *p, ::FormWidgetButton *w); + /// \endcond + virtual ~FormFieldButton(); + + virtual FormType type() const; + + /** + The particular type of the button field. + */ + ButtonType buttonType() const; + + /** + * The caption to be used for the button. + */ + QString caption() const; + + /** + The state of the button. + */ + bool state() const; + + /** + Sets the state of the button to the new \p state . + */ + void setState( bool state ); + + /** + The list with the IDs of siblings (ie, buttons belonging to the same + group as the current one. + + Valid only for \ref Radio buttons, an empty list otherwise. + */ + QList siblings() const; + + private: + Q_DISABLE_COPY(FormFieldButton) + }; + + /** + A form field that represents a text input. + + \since 0.6 + */ + class POPPLER_QT5_EXPORT FormFieldText : public FormField { + public: + + /** + The particular type of this text field. + */ + enum TextType { + Normal, ///< A simple singleline text field. + Multiline, ///< A multiline text field. + FileSelect ///< An input field to select the path of a file on disk. + }; + + /// \cond PRIVATE + FormFieldText(DocumentData *doc, ::Page *p, ::FormWidgetText *w); + /// \endcond + virtual ~FormFieldText(); + + virtual FormType type() const; + + /** + The text type of the text field. + */ + TextType textType() const; + + /** + The text associated with the text field. + */ + QString text() const; + + /** + Sets the text associated with the text field to the specified + \p text. + */ + void setText( const QString& text ); + + /** + Whether this text field is a password input, eg its text \b must be + replaced with asterisks. + + Always false for \ref FileSelect text fields. + */ + bool isPassword() const; + + /** + Whether this text field should allow rich text. + */ + bool isRichText() const; + + /** + The maximum length for the text of this field, or -1 if not set. + */ + int maximumLength() const; + + /** + The horizontal alignment for the text of this text field. + */ + Qt::Alignment textAlignment() const; + + /** + Whether the text inserted manually in the field (where possible) + can be spell-checked. + */ + bool canBeSpellChecked() const; + + private: + Q_DISABLE_COPY(FormFieldText) + }; + + /** + A form field that represents a choice field. + + \since 0.6 + */ + class POPPLER_QT5_EXPORT FormFieldChoice : public FormField { + public: + + /** + The particular type of this choice field. + */ + enum ChoiceType { + ComboBox, ///< A simple singleline text field. + ListBox ///< A multiline text field. + }; + + /// \cond PRIVATE + FormFieldChoice(DocumentData *doc, ::Page *p, ::FormWidgetChoice *w); + /// \endcond + virtual ~FormFieldChoice(); + + virtual FormType type() const; + + /** + The choice type of the choice field. + */ + ChoiceType choiceType() const; + + /** + The possible choices of the choice field. + */ + QStringList choices() const; + + /** + Whether this FormFieldChoice::ComboBox is editable, i.e. the user + can type in a custom value. + + Always false for the other types of choices. + */ + bool isEditable() const; + + /** + Whether more than one choice of this FormFieldChoice::ListBox + can be selected at the same time. + + Always false for the other types of choices. + */ + bool multiSelect() const; + + /** + The currently selected choices. + */ + QList currentChoices() const; + + /** + Sets the selected choices to \p choice. + */ + void setCurrentChoices( const QList &choice ); + + /** + The text entered into an editable combo box choice field. Otherwise a null string. + + \since 0.22 + */ + QString editChoice() const; + + /** + Sets the text entered into an editable combo box choice field. Otherwise does nothing. + + \since 0.22 + */ + void setEditChoice(const QString& text); + + /** + The horizontal alignment for the text of this text field. + */ + Qt::Alignment textAlignment() const; + + /** + Whether the text inserted manually in the field (where possible) + can be spell-checked. + + Returns false if the field is not an editable text field. + */ + bool canBeSpellChecked() const; + + private: + Q_DISABLE_COPY(FormFieldChoice) + }; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-link-extractor-private.h b/dependencies/poppler/include/qt5/poppler-link-extractor-private.h new file mode 100644 index 00000000..32ddd038 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-link-extractor-private.h @@ -0,0 +1,57 @@ +/* poppler-link-extractor_p.h: qt interface to poppler + * Copyright (C) 2007, 2008, 2011, Pino Toscano + * + * 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_LINK_EXTRACTOR_H_ +#define _POPPLER_LINK_EXTRACTOR_H_ + +#include +#include + +#include + +namespace Poppler +{ + +class Link; +class PageData; + +class LinkExtractorOutputDev : public OutputDev +{ + public: + LinkExtractorOutputDev(PageData *data); + virtual ~LinkExtractorOutputDev(); + + // inherited from OutputDev + virtual GBool upsideDown() { return gFalse; } + virtual GBool useDrawChar() { return gFalse; } + virtual GBool interpretType3Chars() { return gFalse; } + virtual void processLink(::AnnotLink *link); + + // our stuff + QList< Link* > links(); + + private: + PageData *m_data; + double m_pageCropWidth; + double m_pageCropHeight; + QList< Link* > m_links; +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-link.h b/dependencies/poppler/include/qt5/poppler-link.h new file mode 100644 index 00000000..172effa2 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-link.h @@ -0,0 +1,602 @@ +/* poppler-link.h: qt interface to poppler + * Copyright (C) 2006, 2013, Albert Astals Cid + * Copyright (C) 2007-2008, 2010, Pino Toscano + * Copyright (C) 2010, 2012, Guillermo Amaral + * Copyright (C) 2012, Tobias Koenig + * Copyright (C) 2013, Anthony Granger + * Adapting code from + * Copyright (C) 2004 by Enrico Ros + * + * 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_LINK_H_ +#define _POPPLER_LINK_H_ + +#include +#include +#include +#include "poppler-export.h" + +struct Ref; +class MediaRendition; + +namespace Poppler { + +class LinkPrivate; +class LinkGotoPrivate; +class LinkExecutePrivate; +class LinkBrowsePrivate; +class LinkActionPrivate; +class LinkSoundPrivate; +class LinkJavaScriptPrivate; +class LinkMoviePrivate; +class LinkDestinationData; +class LinkDestinationPrivate; +class LinkRenditionPrivate; +class MediaRendition; +class SoundObject; + +/** + * \short A destination. + * + * The LinkDestination class represent a "destination" (in terms of visual + * viewport to be displayed) for \link Poppler::LinkGoto GoTo\endlink links, + * and items in the table of contents (TOC) of a document. + * + * Coordinates are in 0..1 range + */ +class POPPLER_QT5_EXPORT LinkDestination +{ + public: + /** + * The possible kind of "viewport destination". + */ + enum Kind + { + /** + * The new viewport is specified in terms of: + * - possibile new left coordinate (see isChangeLeft() ) + * - possibile new top coordinate (see isChangeTop() ) + * - possibile new zoom level (see isChangeZoom() ) + */ + destXYZ = 1, + destFit = 2, + destFitH = 3, + destFitV = 4, + destFitR = 5, + destFitB = 6, + destFitBH = 7, + destFitBV = 8 + }; + + /// \cond PRIVATE + LinkDestination(const LinkDestinationData &data); + LinkDestination(const QString &description); + /// \endcond + /** + * Copy constructor. + */ + LinkDestination(const LinkDestination &other); + /** + * Destructor. + */ + ~LinkDestination(); + + // Accessors. + /** + * The kind of destination. + */ + Kind kind() const; + /** + * Which page is the target of this destination. + * + * \note this number is 1-based, so for a 5 pages document the + * valid page numbers go from 1 to 5 (both included). + */ + int pageNumber() const; + /** + * The new left for the viewport of the target page, in case + * it is specified to be changed (see isChangeLeft() ) + */ + double left() const; + double bottom() const; + double right() const; + /** + * The new top for the viewport of the target page, in case + * it is specified to be changed (see isChangeTop() ) + */ + double top() const; + double zoom() const; + /** + * Whether the left of the viewport on the target page should + * be changed. + * + * \see left() + */ + bool isChangeLeft() const; + /** + * Whether the top of the viewport on the target page should + * be changed. + * + * \see top() + */ + bool isChangeTop() const; + /** + * Whether the zoom level should be changed. + * + * \see zoom() + */ + bool isChangeZoom() const; + + /** + * Return a string repesentation of this destination. + */ + QString toString() const; + + /** + * Return the name of this destination. + * + * \since 0.12 + */ + QString destinationName() const; + + /** + * Assignment operator. + */ + LinkDestination& operator=(const LinkDestination &other); + + private: + QSharedDataPointer< LinkDestinationPrivate > d; +}; + +/** + * \short Encapsulates data that describes a link. + * + * This is the base class for links. It makes mandatory for inherited + * kind of links to reimplement the linkType() method and return the type of + * the link described by the reimplemented class. + */ +class POPPLER_QT5_EXPORT Link +{ + public: + /// \cond PRIVATE + Link( const QRectF &linkArea ); + /// \endcond + + /** + * The possible kinds of link. + * + * Inherited classes must return an unique identifier + */ + enum LinkType + { + None, ///< Unknown link + Goto, ///< A "Go To" link + Execute, ///< A command to be executed + Browse, ///< An URL to be browsed (eg "http://poppler.freedesktop.org") + Action, ///< A "standard" action to be executed in the viewer + Sound, ///< A link representing a sound to be played + Movie, ///< An action to be executed on a movie + Rendition, ///< A rendition link \since 0.20 + JavaScript ///< A JavaScript code to be interpreted \since 0.10 + }; + + /** + * The type of this link. + */ + virtual LinkType linkType() const; + + /** + * Destructor. + */ + virtual ~Link(); + + /** + * The area of a Page where the link should be active. + * + * \note this can be a null rect, in this case the link represents + * a general action. The area is given in 0..1 range + */ + QRectF linkArea() const; + + protected: + /// \cond PRIVATE + Link( LinkPrivate &dd ); + Q_DECLARE_PRIVATE( Link ) + LinkPrivate *d_ptr; + /// \endcond + + private: + Q_DISABLE_COPY( Link ) +}; + + +/** + * \brief Viewport reaching request. + * + * With a LinkGoto link, the document requests the specified viewport to be + * reached (aka, displayed in a viewer). Furthermore, if a file name is specified, + * then the destination refers to that document (and not to the document the + * current LinkGoto belongs to). + */ +class POPPLER_QT5_EXPORT LinkGoto : public Link +{ + public: + /** + * Create a new Goto link. + * + * \param linkArea the active area of the link + * \param extFileName if not empty, the file name to be open + * \param destination the destination to be reached + */ + LinkGoto( const QRectF &linkArea, QString extFileName, const LinkDestination & destination ); + /** + * Destructor. + */ + ~LinkGoto(); + + /** + * Whether the destination is in an external document + * (i.e. not the current document) + */ + bool isExternal() const; + // query for goto parameters + /** + * The file name of the document the destination() refers to, + * or an empty string in case it refers to the current document. + */ + QString fileName() const; + /** + * The destination to reach. + */ + LinkDestination destination() const; + LinkType linkType() const; + + private: + Q_DECLARE_PRIVATE( LinkGoto ) + Q_DISABLE_COPY( LinkGoto ) +}; + +/** + * \brief Generic execution request. + * + * The LinkExecute link represent a "file name" execution request. The result + * depends on the \link fileName() file name\endlink: + * - if it is a document, then it is requested to be open + * - otherwise, it represents an executable to be run with the specified parameters + */ +class POPPLER_QT5_EXPORT LinkExecute : public Link +{ + public: + /** + * The file name to be executed + */ + QString fileName() const; + /** + * The parameters for the command. + */ + QString parameters() const; + + /** + * Create a new Execute link. + * + * \param linkArea the active area of the link + * \param file the file name to be open, or the program to be execute + * \param params the parameters for the program to execute + */ + LinkExecute( const QRectF &linkArea, const QString & file, const QString & params ); + /** + * Destructor. + */ + ~LinkExecute(); + LinkType linkType() const; + + private: + Q_DECLARE_PRIVATE( LinkExecute ) + Q_DISABLE_COPY( LinkExecute ) +}; + +/** + * \brief An URL to browse. + * + * The LinkBrowse link holds a URL (eg 'http://poppler.freedesktop.org', + * 'mailto:john@some.org', etc) to be open. + * + * The format of the URL is specified by RFC 2396 (http://www.ietf.org/rfc/rfc2396.txt) + */ +class POPPLER_QT5_EXPORT LinkBrowse : public Link +{ + public: + /** + * The URL to open + */ + QString url() const; + + /** + * Create a new browse link. + * + * \param linkArea the active area of the link + * \param url the URL to be open + */ + LinkBrowse( const QRectF &linkArea, const QString &url ); + /** + * Destructor. + */ + ~LinkBrowse(); + LinkType linkType() const; + + private: + Q_DECLARE_PRIVATE( LinkBrowse ) + Q_DISABLE_COPY( LinkBrowse ) +}; + +/** + * \brief "Standard" action request. + * + * The LinkAction class represents a link that request a "standard" action + * to be performed by the viewer on the displayed document. + */ +class POPPLER_QT5_EXPORT LinkAction : public Link +{ + public: + /** + * The possible types of actions + */ + enum ActionType { PageFirst = 1, + PagePrev = 2, + PageNext = 3, + PageLast = 4, + HistoryBack = 5, + HistoryForward = 6, + Quit = 7, + Presentation = 8, + EndPresentation = 9, + Find = 10, + GoToPage = 11, + Close = 12, + Print = 13 ///< \since 0.16 + }; + + /** + * The action of the current LinkAction + */ + ActionType actionType() const; + + /** + * Create a new Action link, that executes a specified action + * on the document. + * + * \param linkArea the active area of the link + * \param actionType which action should be executed + */ + LinkAction( const QRectF &linkArea, ActionType actionType ); + /** + * Destructor. + */ + ~LinkAction(); + LinkType linkType() const; + + private: + Q_DECLARE_PRIVATE( LinkAction ) + Q_DISABLE_COPY( LinkAction ) +}; + +/** + * Sound: a sound to be played. + * + * \since 0.6 + */ +class POPPLER_QT5_EXPORT LinkSound : public Link +{ + public: + // create a Link_Sound + LinkSound( const QRectF &linkArea, double volume, bool sync, bool repeat, bool mix, SoundObject *sound ); + /** + * Destructor. + */ + virtual ~LinkSound(); + + LinkType linkType() const; + + /** + * The volume to be used when playing the sound. + * + * The volume is in the range [ -1, 1 ], where: + * - a negative number: no volume (mute) + * - 1: full volume + */ + double volume() const; + /** + * Whether the playback of the sound should be synchronous + * (thus blocking, waiting for the end of the sound playback). + */ + bool synchronous() const; + /** + * Whether the sound should be played continuously (that is, + * started again when it ends) + */ + bool repeat() const; + /** + * Whether the playback of this sound can be mixed with + * playbacks with other sounds of the same document. + * + * \note When false, any other playback must be stopped before + * playing the sound. + */ + bool mix() const; + /** + * The sound object to be played + */ + SoundObject *sound() const; + + private: + Q_DECLARE_PRIVATE( LinkSound ) + Q_DISABLE_COPY( LinkSound ) +}; + +/** + * Rendition: Rendition link. + * + * \since 0.20 + */ +class POPPLER_QT5_EXPORT LinkRendition : public Link +{ + public: + /** + * Describes the possible rendition actions. + * + * \since 0.22 + */ + enum RenditionAction { + NoRendition, + PlayRendition, + StopRendition, + PauseRendition, + ResumeRendition + }; + + /** + * Create a new rendition link. + * + * \param linkArea the active area of the link + * \param rendition the media rendition object. Ownership is taken + * \param operation the numeric operation (action) (@see ::LinkRendition::RenditionOperation) + * \param script the java script code + * \param annotationReference the object reference of the screen annotation associated with this rendition action + * \since 0.22 + */ + LinkRendition( const QRectF &linkArea, ::MediaRendition *rendition, int operation, const QString &script, const Ref &annotationReference ); + + /** + * Destructor. + */ + virtual ~LinkRendition(); + + LinkType linkType() const; + + /** + * Returns the media rendition object if the redition provides one, @c 0 otherwise + */ + MediaRendition *rendition() const; + + /** + * Returns the action that should be executed if a rendition object is provided. + * + * \since 0.22 + */ + RenditionAction action() const; + + /** + * The JS code that shall be executed or an empty string. + * + * \since 0.22 + */ + QString script() const; + + /** + * Returns whether the given @p annotation is the referenced screen annotation for this rendition @p link. + * + * \since 0.22 + */ + bool isReferencedAnnotation( const ScreenAnnotation *annotation ) const; + + private: + Q_DECLARE_PRIVATE( LinkRendition ) + Q_DISABLE_COPY( LinkRendition ) +}; + +/** + * JavaScript: a JavaScript code to be interpreted. + * + * \since 0.10 + */ +class POPPLER_QT5_EXPORT LinkJavaScript : public Link +{ + public: + /** + * Create a new JavaScript link. + * + * \param linkArea the active area of the link + * \param js the JS code to be interpreted + */ + LinkJavaScript( const QRectF &linkArea, const QString &js ); + /** + * Destructor. + */ + virtual ~LinkJavaScript(); + + LinkType linkType() const; + + /** + * The JS code + */ + QString script() const; + + private: + Q_DECLARE_PRIVATE( LinkJavaScript ) + Q_DISABLE_COPY( LinkJavaScript ) +}; + +/** + * Movie: a movie to be played. + * + * \since 0.20 + */ +class POPPLER_QT5_EXPORT LinkMovie : public Link +{ + public: + /** + * Describes the operation to be performed on the movie. + */ + enum Operation { Play, + Stop, + Pause, + Resume + }; + + /** + * Create a new Movie link. + * + * \param linkArea the active area of the link + * \param operation the operation to be performed on the movie + * \param annotationTitle the title of the movie annotation identifying the movie to be played + * \param annotationReference the object reference of the movie annotation identifying the movie to be played + * + * Note: This constructor is supposed to be used by Poppler::Page only. + */ + LinkMovie( const QRectF &linkArea, Operation operation, const QString &annotationTitle, const Ref &annotationReference ); + /** + * Destructor. + */ + ~LinkMovie(); + LinkType linkType() const; + /** + * Returns the operation to be performed on the movie. + */ + Operation operation() const; + /** + * Returns whether the given @p annotation is the referenced movie annotation for this movie @p link. + */ + bool isReferencedAnnotation( const MovieAnnotation *annotation ) const; + + private: + Q_DECLARE_PRIVATE( LinkMovie ) + Q_DISABLE_COPY( LinkMovie ) +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-media.h b/dependencies/poppler/include/qt5/poppler-media.h new file mode 100644 index 00000000..40b8cae3 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-media.h @@ -0,0 +1,100 @@ +/* poppler-media.h: qt interface to poppler + * Copyright (C) 2012 Guillermo A. Amaral B. + * Copyright (C) 2012, 2013 Albert Astals Cid + * + * 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_MEDIARENDITION_H__ +#define __POPPLER_MEDIARENDITION_H__ + +#include "poppler-export.h" + +#include +#include + +class MediaRendition; +class QIODevice; + +namespace Poppler +{ + class MediaRenditionPrivate; + + /** + Qt wrapper for MediaRendition. + + \since 0.20 + */ + class POPPLER_QT5_EXPORT MediaRendition { + public: + /** + Constructs a MediaRendition. Takes ownership of the passed rendition + */ + MediaRendition(::MediaRendition *rendition); + ~MediaRendition(); + + /** + Check if wrapper is holding a valid rendition object. + */ + bool isValid() const; + + /** + Returns content type. + */ + QString contentType() const; + + /** + Returns file name. + */ + QString fileName() const; + + /** + Returns true if media is embedded. + */ + bool isEmbedded() const; + + /** + Returns data buffer. + */ + QByteArray data() const; + + /** + Convenience accessor for auto-play parameter. + */ + bool autoPlay() const; + + /** + Convenience accessor for show controls parameter. + */ + bool showControls() const; + + /** + Convenience accessor for repeat count parameter. + */ + float repeatCount() const; + + /** + Convenience accessor for size parameter. + */ + QSize size() const; + + private: + Q_DECLARE_PRIVATE( MediaRendition ) + MediaRenditionPrivate *d_ptr; + Q_DISABLE_COPY( MediaRendition ) + }; +} + +#endif /* __POPPLER_MEDIARENDITION_H__ */ diff --git a/dependencies/poppler/include/qt5/poppler-optcontent-private.h b/dependencies/poppler/include/qt5/poppler-optcontent-private.h new file mode 100644 index 00000000..98eda073 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-optcontent-private.h @@ -0,0 +1,121 @@ +/* poppler-optcontent-private.h: qt interface to poppler + * + * Copyright (C) 2007, Brad Hards + * Copyright (C) 2008, Pino Toscano + * + * 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_OPTCONTENT_PRIVATE_H +#define POPPLER_OPTCONTENT_PRIVATE_H + +#include +#include +#include + +class Array; +class OCGs; +class OptionalContentGroup; + +class QModelIndex; + +namespace Poppler +{ + class OptContentItem; + class OptContentModel; + class OptContentModelPrivate; + + class RadioButtonGroup + { + public: + RadioButtonGroup( OptContentModelPrivate *ocModel, Array *rbarray); + ~RadioButtonGroup(); + QSet setItemOn( OptContentItem *itemToSetOn ); + + private: + QList itemsInGroup; + }; + + class OptContentItem + { + public: + enum ItemState { On, Off, HeadingOnly }; + + OptContentItem( OptionalContentGroup *group ); + OptContentItem( const QString &label ); + OptContentItem(); + ~OptContentItem(); + + QString name() const { return m_name; } + ItemState state() const { return m_stateBackup; } + bool setState(ItemState state, QSet &changedItems); + + QList childList() { return m_children; } + + void setParent( OptContentItem* parent) { m_parent = parent; } + OptContentItem* parent() { return m_parent; } + + void addChild( OptContentItem *child ); + + void appendRBGroup( RadioButtonGroup *rbgroup ); + + bool isEnabled() const { return m_enabled; } + + QSet recurseListChildren(bool includeMe = false) const; + + private: + OptionalContentGroup *m_group; + QString m_name; + ItemState m_state; // true for ON, false for OFF + ItemState m_stateBackup; + QList m_children; + OptContentItem *m_parent; + QList m_rbGroups; + bool m_enabled; + }; + + class OptContentModelPrivate + { + public: + OptContentModelPrivate( OptContentModel *qq, OCGs *optContent ); + ~OptContentModelPrivate(); + + void parseRBGroupsArray( Array *rBGroupArray ); + OptContentItem *nodeFromIndex(const QModelIndex &index, bool canBeNull = false) const; + QModelIndex indexFromItem(OptContentItem *node, int column) const; + + /** + Get the OptContentItem corresponding to a given reference value. + + \param ref the reference number (e.g. from Object.getRefNum()) to look up + + \return the matching optional content item, or null if the reference wasn't found + */ + OptContentItem *itemFromRef( const QString &ref ) const; + void setRootNode(OptContentItem *node); + + OptContentModel *q; + + QMap m_optContentItems; + QList m_rbgroups; + OptContentItem *m_rootNode; + + private: + void addChild( OptContentItem *parent, OptContentItem *child); + void parseOrderArray( OptContentItem *parentNode, Array *orderArray ); + }; +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-optcontent.h b/dependencies/poppler/include/qt5/poppler-optcontent.h new file mode 100644 index 00000000..ad75da8c --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-optcontent.h @@ -0,0 +1,77 @@ +/* poppler-optcontent.h: qt interface to poppler + * + * Copyright (C) 2007, Brad Hards + * Copyright (C) 2008, Pino Toscano + * Copyright (C) 2013, Anthony Granger + * + * 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_OPTCONTENT_H +#define POPPLER_OPTCONTENT_H + +#include + +#include "poppler-export.h" + +class OCGs; + +namespace Poppler +{ + class Document; + class OptContentModelPrivate; + + /** + * \brief Model for optional content + * + * OptContentModel is an item model representing the optional content items + * that can be found in PDF documents. + * + * The model offers a mostly read-only display of the data, allowing to + * enable/disable some contents setting the Qt::CheckStateRole data role. + * + * \since 0.8 + */ + class POPPLER_QT5_EXPORT OptContentModel : public QAbstractItemModel + { + friend class Document; + + Q_OBJECT + + public: + virtual ~OptContentModel(); + + QModelIndex index(int row, int column, const QModelIndex &parent) const; + QModelIndex parent(const QModelIndex &child) const; + + int rowCount(const QModelIndex &parent = QModelIndex()) const; + int columnCount(const QModelIndex &parent) const; + + QVariant data(const QModelIndex &index, int role) const; + virtual bool setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ); + + Qt::ItemFlags flags ( const QModelIndex & index ) const; + + virtual QVariant headerData( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const; + + private: + OptContentModel( OCGs *optContent, QObject *parent = 0); + + friend class OptContentModelPrivate; + OptContentModelPrivate *d; + }; +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-page-private.h b/dependencies/poppler/include/qt5/poppler-page-private.h new file mode 100644 index 00000000..91955e09 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-page-private.h @@ -0,0 +1,54 @@ +/* poppler-page.cc: qt interface to poppler + * Copyright (C) 2005, Net Integration Technologies, Inc. + * Copyright (C) 2007, 2012, Albert Astals Cid + * Copyright (C) 2008, Pino Toscano + * + * 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_PAGE_PRIVATE_H_ +#define _POPPLER_PAGE_PRIVATE_H_ + +#include "CharTypes.h" + +class QRectF; + +class LinkAction; +class Page; +class TextPage; + +namespace Poppler +{ + +class DocumentData; +class PageTransition; + +class PageData { +public: + Link* convertLinkActionToLink(::LinkAction * a, const QRectF &linkArea); + + DocumentData *parentDoc; + ::Page *page; + int index; + PageTransition *transition; + + static Link* convertLinkActionToLink(::LinkAction * a, DocumentData *parentDoc, const QRectF &linkArea); + + TextPage *prepareTextSearch(const QString &text, Page::SearchMode caseSensitive, Page::Rotation rotate, GBool *sCase, QVector *u); +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-page-transition-private.h b/dependencies/poppler/include/qt5/poppler-page-transition-private.h new file mode 100644 index 00000000..63febb09 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-page-transition-private.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2005, Albert Astals Cid + * + * 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. + */ + +class Object; + +namespace Poppler { + +class PageTransitionParams { + public: + Object *dictObj; +}; + +} diff --git a/dependencies/poppler/include/qt5/poppler-page-transition.h b/dependencies/poppler/include/qt5/poppler-page-transition.h new file mode 100644 index 00000000..2d408a51 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-page-transition.h @@ -0,0 +1,148 @@ +/* PageTransition.h + * Copyright (C) 2005, Net Integration Technologies, Inc. + * Copyright (C) 2005, Brad Hards + * + * 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 __PAGETRANSITION_X_H__ +#define __PAGETRANSITION_X_H__ + +#include "poppler-export.h" + +namespace Poppler { + +class PageTransitionParams; +class PageTransitionData; + +/** + \brief Describes how a PDF file viewer shall perform the transition + from one page to another + + In PDF files there is a way to specify if the viewer shall use + certain effects to perform the transition from one page to + another. This feature can be used, e.g., in a PDF-based beamer + presentation. + + This utility class represents the transition effect, and can be + used to extract the information from a PDF object. +*/ + + +class POPPLER_QT5_EXPORT PageTransition { + public: + + /** \brief transition effect that shall be used + */ + // if changed remember to keep in sync with PageTransition.h enum + enum Type { + Replace = 0, + Split, + Blinds, + Box, + Wipe, + Dissolve, + Glitter, + Fly, + Push, + Cover, + Uncover, + Fade + }; + + /** \brief alignment of the transition effect that shall be used + */ + // if changed remember to keep in sync with PageTransition.h enum + enum Alignment { + Horizontal = 0, + Vertical + }; + + /** \brief direction of the transition effect that shall be used + */ + // if changed remember to keep in sync with PageTransition.h enum + enum Direction { + Inward = 0, + Outward + }; + + /** \brief Construct a new PageTransition object from a page dictionary. + + Users of the library will rarely need to construct a + PageTransition object themselves. Instead, the method + Poppler::Page::transition() can be used to find out if a certain + transition effect is specified. + + @warning In case or error, this method will print an error message to stderr, + and construct a default object. + + @param params an object whose dictionary will be read and + parsed. This must be a valid object, whose dictionaries are + accessed by the constructor. The object is only accessed by this + constructor, and may be deleted after the constructor returns. + */ + PageTransition(const PageTransitionParams ¶ms); + + /** \brief copy constructor */ + PageTransition(const PageTransition &pt); + + /** + Destructor + */ + ~PageTransition(); + + /** + \brief Get type of the transition. + */ + Type type() const; + + /** + \brief Get duration of the transition in seconds. + */ + int duration() const; + + /** + \brief Get dimension in which the transition effect occurs. + */ + Alignment alignment() const; + + /** + \brief Get direction of motion of the transition effect. + */ + Direction direction() const; + + /** + \brief Get direction in which the transition effect moves. + */ + int angle() const; + + /** + \brief Get starting or ending scale. + */ + double scale() const; + + /** + \brief Returns true if the area to be flown is rectangular and + opaque. + */ + bool isRectangular() const; + + private: + PageTransitionData *data; +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-private.h b/dependencies/poppler/include/qt5/poppler-private.h new file mode 100644 index 00000000..0a132f07 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-private.h @@ -0,0 +1,240 @@ +/* poppler-private.h: qt interface to poppler + * Copyright (C) 2005, Net Integration Technologies, Inc. + * Copyright (C) 2005, 2008, Brad Hards + * Copyright (C) 2006-2009, 2011, 2012 by Albert Astals Cid + * Copyright (C) 2007-2009, 2011 by Pino Toscano + * Copyright (C) 2011 Andreas Hartmetz + * Copyright (C) 2011 Hib Eris + * Copyright (C) 2012, 2013 Thomas Freitag + * Copyright (C) 2013 Anthony Granger + * Inspired on code by + * Copyright (C) 2004 by Albert Astals Cid + * Copyright (C) 2004 by Enrico Ros + * + * 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_PRIVATE_H_ +#define _POPPLER_PRIVATE_H_ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#if defined(HAVE_SPLASH) +#include +#endif + +#include "poppler-qt5.h" +#include "poppler-embeddedfile-private.h" + +class LinkDest; +class FormWidget; + +namespace Poppler { + + /* borrowed from kpdf */ + QString unicodeToQString(Unicode* u, int len); + + QString UnicodeParsedString(GooString *s1); + + GooString *QStringToUnicodeGooString(const QString &s); + + GooString *QStringToGooString(const QString &s); + + void qt5ErrorFunction(int pos, char *msg, va_list args); + + class LinkDestinationData + { + public: + LinkDestinationData( LinkDest *l, GooString *nd, Poppler::DocumentData *pdfdoc, bool external ) + : ld(l), namedDest(nd), doc(pdfdoc), externalDest(external) + { + } + + LinkDest *ld; + GooString *namedDest; + Poppler::DocumentData *doc; + bool externalDest; + }; + + class DocumentData { + public: + DocumentData(const QString &filePath, GooString *ownerPassword, GooString *userPassword) + { + init(); + m_filePath = filePath; + +#if defined(_WIN32) + wchar_t *fileName = new WCHAR[filePath.length()]; + int length = filePath.toWCharArray(fileName); + doc = new PDFDoc(fileName, length, ownerPassword, userPassword); + delete[] fileName; +#else + GooString *fileName = new GooString(QFile::encodeName(filePath)); + doc = new PDFDoc(fileName, ownerPassword, userPassword); +#endif + + delete ownerPassword; + delete userPassword; + } + + DocumentData(const QByteArray &data, GooString *ownerPassword, GooString *userPassword) + { + Object obj; + fileContents = data; + obj.initNull(); + MemStream *str = new MemStream((char*)fileContents.data(), 0, fileContents.length(), &obj); + init(); + doc = new PDFDoc(str, ownerPassword, userPassword); + delete ownerPassword; + delete userPassword; + } + + void init(); + + ~DocumentData(); + + void addTocChildren( QDomDocument * docSyn, QDomNode * parent, GooList * items ); + + void setPaperColor(const QColor &color) + { + paperColor = color; + } + + void fillMembers() + { + m_fontInfoIterator = new FontIterator(0, this); + int numEmb = doc->getCatalog()->numEmbeddedFiles(); + if (!(0 == numEmb)) { + // we have some embedded documents, build the list + for (int yalv = 0; yalv < numEmb; ++yalv) { + FileSpec *fs = doc->getCatalog()->embeddedFile(yalv); + m_embeddedFiles.append(new EmbeddedFile(*new EmbeddedFileData(fs))); + } + } + } + + static Document *checkDocument(DocumentData *doc); + + PDFDoc *doc; + QString m_filePath; + QByteArray fileContents; + bool locked; + FontIterator *m_fontInfoIterator; + Document::RenderBackend m_backend; + QList m_embeddedFiles; + QPointer m_optContentModel; + QColor paperColor; + int m_hints; + static int count; + }; + + class FontInfoData + { + public: + FontInfoData() + { + isEmbedded = false; + isSubset = false; + type = FontInfo::unknown; + } + + FontInfoData( const FontInfoData &fid ) + { + fontName = fid.fontName; + fontFile = fid.fontFile; + isEmbedded = fid.isEmbedded; + isSubset = fid.isSubset; + type = fid.type; + embRef = fid.embRef; + } + + FontInfoData( ::FontInfo* fi ) + { + if (fi->getName()) fontName = fi->getName()->getCString(); + if (fi->getFile()) fontFile = fi->getFile()->getCString(); + isEmbedded = fi->getEmbedded(); + isSubset = fi->getSubset(); + type = (Poppler::FontInfo::Type)fi->getType(); + embRef = fi->getEmbRef(); + } + + QString fontName; + QString fontFile; + bool isEmbedded : 1; + bool isSubset : 1; + FontInfo::Type type; + Ref embRef; + }; + + class FontIteratorData + { + public: + FontIteratorData( int startPage, DocumentData *dd ) + : fontInfoScanner( dd->doc, startPage ) + , totalPages( dd->doc->getNumPages() ) + , currentPage( qMax( startPage, 0 ) - 1 ) + { + } + + ~FontIteratorData() + { + } + + FontInfoScanner fontInfoScanner; + int totalPages; + int currentPage; + }; + + class TextBoxData + { + public: + TextBoxData() + : nextWord(0), hasSpaceAfter(false) + { + } + + QString text; + QRectF bBox; + TextBox *nextWord; + QVector charBBoxes; // the boundingRect of each character + bool hasSpaceAfter; + }; + + class FormFieldData + { + public: + FormFieldData(DocumentData *_doc, ::Page *p, ::FormWidget *w) : + doc(_doc), page(p), fm(w) + { + } + + DocumentData *doc; + ::Page *page; + ::FormWidget *fm; + QRectF box; + }; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-qiodeviceoutstream-private.h b/dependencies/poppler/include/qt5/poppler-qiodeviceoutstream-private.h new file mode 100644 index 00000000..af0d46b1 --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-qiodeviceoutstream-private.h @@ -0,0 +1,47 @@ +/* poppler-qiodevicestream-private.h: Qt5 interface to poppler + * Copyright (C) 2008, Pino Toscano + * Copyright (C) 2013 Adrian Johnson + * + * 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_QIODEVICESTREAM_PRIVATE_H +#define POPPLER_QIODEVICESTREAM_PRIVATE_H + +#include "Object.h" +#include "Stream.h" + +class QIODevice; + +namespace Poppler { + +class QIODeviceOutStream : public OutStream +{ + public: + QIODeviceOutStream(QIODevice* device); + virtual ~QIODeviceOutStream(); + + virtual void close(); + virtual Goffset getPos(); + virtual void put(char c); + virtual void printf(const char *format, ...); + + private: + QIODevice *m_device; +}; + +} + +#endif diff --git a/dependencies/poppler/include/qt5/poppler-qt5.h b/dependencies/poppler/include/qt5/poppler-qt5.h new file mode 100644 index 00000000..0eb0b44a --- /dev/null +++ b/dependencies/poppler/include/qt5/poppler-qt5.h @@ -0,0 +1,1771 @@ +/* poppler-qt.h: qt interface to poppler + * Copyright (C) 2005, Net Integration Technologies, Inc. + * Copyright (C) 2005, 2007, Brad Hards + * Copyright (C) 2005-2013, Albert Astals Cid + * Copyright (C) 2005, Stefan Kebekus + * Copyright (C) 2006-2011, Pino Toscano + * Copyright (C) 2009 Shawn Rutledge + * Copyright (C) 2010 Suzuki Toshiya + * Copyright (C) 2010 Matthias Fauconneau + * Copyright (C) 2011 Andreas Hartmetz + * Copyright (C) 2011 Glad Deschrijver + * Copyright (C) 2012, Guillermo A. Amaral B. + * Copyright (C) 2012, Fabio D'Urso + * Copyright (C) 2012, Tobias Koenig + * Copyright (C) 2012 Adam Reichold + * Copyright (C) 2012, 2013 Thomas Freitag + * Copyright (C) 2013 Anthony Granger + * + * 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 +#include +#include +#include +#include "poppler-export.h" + +class EmbFile; +class Sound; +class AnnotMovie; + +/** + The %Poppler Qt5 binding. +*/ +namespace Poppler { + + class Document; + class DocumentData; + + class PageData; + + class FormField; + + class TextBoxData; + + class PDFConverter; + class PSConverter; + + /** + Debug/error function. + + This function type is used for debugging & error output; + the first parameter is the actual message, the second is the unaltered + closure argument which was passed to the setDebugErrorFunction call. + + \since 0.16 + */ + typedef void (*PopplerDebugFunc)(const QString & /*message*/, const QVariant & /*closure*/); + + /** + Set a new debug/error output function. + + If not set, by default error and debug messages will be sent to the + Qt \p qDebug() function. + + \param debugFunction the new debug function + \param closure user data which will be passes as-is to the debug function + + \since 0.16 + */ + POPPLER_QT5_EXPORT void setDebugErrorFunction(PopplerDebugFunc debugFunction, const QVariant &closure); + + /** + Describes the physical location of text on a document page + + This very simple class describes the physical location of text + on the page. It consists of + - a QString that contains the text + - a QRectF that gives a box that describes where on the page + the text is found. + */ + class POPPLER_QT5_EXPORT TextBox { + friend class Page; + public: + /** + The default constructor sets the \p text and the rectangle that + contains the text. Coordinates for the \p bBox are in points = + 1/72 of an inch. + */ + TextBox(const QString& text, const QRectF &bBox); + /** + Destructor. + */ + ~TextBox(); + + /** + Returns the text of this text box + */ + QString text() const; + + /** + Returns the position of the text, in point, i.e., 1/72 of + an inch + + \since 0.8 + */ + QRectF boundingBox() const; + + /** + Returns the pointer to the next text box, if there is one. + + Otherwise, it returns a null pointer. + */ + TextBox *nextWord() const; + + /** + Returns the bounding box of the \p i -th characted of the word. + */ + QRectF charBoundingBox(int i) const; + + /** + Returns whether there is a space character after this text box + */ + bool hasSpaceAfter() const; + + private: + Q_DISABLE_COPY(TextBox) + + TextBoxData *m_data; + }; + + + class FontInfoData; + /** + Container class for information about a font within a PDF + document + */ + class POPPLER_QT5_EXPORT FontInfo { + friend class Document; + public: + /** + The type of font. + */ + enum Type { + unknown, + Type1, + Type1C, + Type1COT, + Type3, + TrueType, + TrueTypeOT, + CIDType0, + CIDType0C, + CIDType0COT, + CIDTrueType, + CIDTrueTypeOT + }; + + /// \cond PRIVATE + /** + Create a new font information container. + */ + FontInfo(); + + /** + Create a new font information container. + */ + FontInfo( const FontInfoData &fid ); + /// \endcond + + /** + Copy constructor. + */ + FontInfo( const FontInfo &fi ); + + /** + Destructor. + */ + ~FontInfo(); + + /** + The name of the font. Can be QString::null if the font has no name + */ + QString name() const; + + /** + The path of the font file used to represent this font on this system, + or a null string is the font is embedded + */ + QString file() const; + + /** + Whether the font is embedded in the file, or not + + \return true if the font is embedded + */ + bool isEmbedded() const; + + /** + Whether the font provided is only a subset of the full + font or not. This only has meaning if the font is embedded. + + \return true if the font is only a subset + */ + bool isSubset() const; + + /** + The type of font encoding + + \return a enumerated value corresponding to the font encoding used + + \sa typeName for a string equivalent + */ + Type type() const; + + /** + The name of the font encoding used + + \note if you are looking for the name of the font (as opposed to the + encoding format used), you probably want name(). + + \sa type for a enumeration version + */ + QString typeName() const; + + /** + Standard assignment operator + */ + FontInfo& operator=( const FontInfo &fi ); + + private: + FontInfoData *m_data; + }; + + + class FontIteratorData; + /** + Iterator for reading the fonts in a document. + + FontIterator provides a Java-style iterator for reading the fonts in a + document. + + You can use it in the following way: + \code +Poppler::FontIterator* it = doc->newFontIterator(); +while (it->hasNext()) { + QList fonts = it->next(); + // do something with the fonts +} +// after doing the job, the iterator must be freed +delete it; + \endcode + + \since 0.12 + */ + class POPPLER_QT5_EXPORT FontIterator { + friend class Document; + friend class DocumentData; + public: + /** + Destructor. + */ + ~FontIterator(); + + /** + Returns the fonts of the current page and then advances the iterator + to the next page. + */ + QList next(); + + /** + Checks whether there is at least one more page to iterate, ie returns + false when the iterator is beyond the last page. + */ + bool hasNext() const; + + /** + Returns the current page where the iterator is. + */ + int currentPage() const; + + private: + Q_DISABLE_COPY( FontIterator ) + FontIterator( int, DocumentData *dd ); + + FontIteratorData *d; + }; + + + class EmbeddedFileData; + /** + Container class for an embedded file with a PDF document + */ + class POPPLER_QT5_EXPORT EmbeddedFile { + friend class DocumentData; + friend class AnnotationPrivate; + public: + /// \cond PRIVATE + EmbeddedFile(EmbFile *embfile); + /// \endcond + + /** + Destructor. + */ + ~EmbeddedFile(); + + /** + The name associated with the file + */ + QString name() const; + + /** + The description associated with the file, if any. + + This will return an empty QString if there is no description element + */ + QString description() const; + + /** + The size of the file. + + This will return < 0 if there is no size element + */ + int size() const; + + /** + The modification date for the embedded file, if known. + */ + QDateTime modDate() const; + + /** + The creation date for the embedded file, if known. + */ + QDateTime createDate() const; + + /** + The MD5 checksum of the file. + + This will return an empty QByteArray if there is no checksum element. + */ + QByteArray checksum() const; + + /** + The MIME type of the file, if known. + + \since 0.8 + */ + QString mimeType() const; + + /** + The data as a byte array + */ + QByteArray data(); + + /** + Is the embedded file valid? + + \since 0.12 + */ + bool isValid() const; + + /** + A QDataStream for the actual data? + */ + //QDataStream dataStream() const; + + private: + Q_DISABLE_COPY(EmbeddedFile) + EmbeddedFile(EmbeddedFileData &dd); + + EmbeddedFileData *m_embeddedFile; + }; + + + /** + \brief A page in a document. + + The Page class represents a single page within a PDF document. + + You cannot construct a Page directly, but you have to use the Document + functions that return a new Page out of an index or a label. + */ + class POPPLER_QT5_EXPORT Page { + friend class Document; + public: + /** + Destructor. + */ + ~Page(); + + /** + The type of rotation to apply for an operation + */ + enum Rotation { Rotate0 = 0, ///< Do not rotate + Rotate90 = 1, ///< Rotate 90 degrees clockwise + Rotate180 = 2, ///< Rotate 180 degrees + Rotate270 = 3 ///< Rotate 270 degrees clockwise (90 degrees counterclockwise) + }; + + /** + The kinds of page actions + */ + enum PageAction { + Opening, ///< The action when a page is "opened" + Closing ///< The action when a page is "closed" + }; + + /** + How the text is going to be returned + \since 0.16 + */ + enum TextLayout { + PhysicalLayout, ///< The text is layouted to resemble the real page layout + RawOrderLayout ///< The text is returned without any type of processing + }; + + /** + Additional flags for the renderToPainter method + \since 0.16 + */ + enum PainterFlag { + /** + Do not save/restore the caller-owned painter. + + renderToPainter() by default preserves, using save() + restore(), + the state of the painter specified; if this is not needed, this + flag can avoid this job + */ + DontSaveAndRestore = 0x00000001 + }; + Q_DECLARE_FLAGS( PainterFlags, PainterFlag ) + + /** + Render the page to a QImage using the current + \link Document::renderBackend() Document renderer\endlink. + + If \p x = \p y = \p w = \p h = -1, the method will automatically + compute the size of the image from the horizontal and vertical + resolutions specified in \p xres and \p yres. Otherwise, the + method renders only a part of the page, specified by the + parameters (\p x, \p y, \p w, \p h) in pixel coordinates. The returned + QImage then has size (\p w, \p h), independent of the page + size. + + \param x specifies the left x-coordinate of the box, in + pixels. + + \param y specifies the top y-coordinate of the box, in + pixels. + + \param w specifies the width of the box, in pixels. + + \param h specifies the height of the box, in pixels. + + \param xres horizontal resolution of the graphics device, + in dots per inch + + \param yres vertical resolution of the graphics device, in + dots per inch + + \param rotate how to rotate the page + + \warning The parameter (\p x, \p y, \p w, \p h) are not + well-tested. Unusual or meaningless parameters may lead to + rather unexpected results. + + \returns a QImage of the page, or a null image on failure. + + \since 0.6 + */ + 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; + + /** + Render the page to the specified QPainter using the current + \link Document::renderBackend() Document renderer\endlink. + + If \p x = \p y = \p w = \p h = -1, the method will automatically + compute the size of the page area from the horizontal and vertical + resolutions specified in \p xres and \p yres. Otherwise, the + method renders only a part of the page, specified by the + parameters (\p x, \p y, \p w, \p h) in pixel coordinates. + + \param painter the painter to paint on + + \param x specifies the left x-coordinate of the box, in + pixels. + + \param y specifies the top y-coordinate of the box, in + pixels. + + \param w specifies the width of the box, in pixels. + + \param h specifies the height of the box, in pixels. + + \param xres horizontal resolution of the graphics device, + in dots per inch + + \param yres vertical resolution of the graphics device, in + dots per inch + + \param rotate how to rotate the page + + \param flags additional painter flags + + \warning The parameter (\p x, \p y, \p w, \p h) are not + well-tested. Unusual or meaningless parameters may lead to + rather unexpected results. + + \returns whether the painting succeeded + + \note This method is only supported for Arthur + + \since 0.16 + */ + 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 = 0) const; + + /** + Get the page thumbnail if it exists. + + \return a QImage of the thumbnail, or a null image + if the PDF does not contain one for this page + + \since 0.12 + */ + QImage thumbnail() const; + + /** + Returns the text that is inside a specified rectangle + + \param rect the rectangle specifying the area of interest, + with coordinates given in points, i.e., 1/72th of an inch. + If rect is null, all text on the page is given + + \since 0.16 + **/ + QString text(const QRectF &rect, TextLayout textLayout) const; + + /** + Returns the text that is inside a specified rectangle. + The text is returned using the physical layout of the page + + \param rect the rectangle specifying the area of interest, + with coordinates given in points, i.e., 1/72th of an inch. + If rect is null, all text on the page is given + **/ + QString text(const QRectF &rect) const; + + /** + The starting point for a search + */ + enum SearchDirection { FromTop, ///< Start sorting at the top of the document + NextResult, ///< Find the next result, moving "down the page" + PreviousResult ///< Find the previous result, moving "up the page" + }; + + /** + The type of search to perform + */ + enum SearchMode { CaseSensitive, ///< Case differences cause no match in searching + CaseInsensitive ///< Case differences are ignored in matching + }; + + /** + Returns true if the specified text was found. + + \param text the text the search + \param rectXXX in all directions is used to return where the text was found, for NextResult and PreviousResult + indicates where to continue searching for + \param direction in which direction do the search + \param caseSensitive be case sensitive? + \param rotate the rotation to apply for the search order + \since 0.14 + **/ + bool search(const QString &text, double &rectLeft, double &rectTop, double &rectRight, double &rectBottom, SearchDirection direction, SearchMode caseSensitive, Rotation rotate = Rotate0) const; + + /** + Returns a list of all occurrences of the specified text on the page. + + \param text the text to search + \param caseSensitive whether to be case sensitive + \param rotate the rotation to apply for the search order + + \warning Do not use the returned QRectF as arguments of another search call because of truncation issues if qreal is defined as float. + + \since 0.22 + **/ + QList search(const QString &text, SearchMode caseSensitive, Rotation rotate = Rotate0) const; + + /** + Returns a list of text of the page + + This method returns a QList of TextBoxes that contain all + the text of the page, with roughly one text word of text + per TextBox item. + + For text written in western languages (left-to-right and + up-to-down), the QList contains the text in the proper + order. + + \note The caller owns the text boxes and they should + be deleted when no longer required. + + \warning This method is not tested with Asian scripts + */ + QList textList(Rotation rotate = Rotate0) const; + + /** + \return The dimensions (cropbox) of the page, in points (i.e. 1/72th of an inch) + */ + QSizeF pageSizeF() const; + + /** + \return The dimensions (cropbox) of the page, in points (i.e. 1/72th of an inch) + */ + QSize pageSize() const; + + /** + Returns the transition of this page + + \returns a pointer to a PageTransition structure that + defines how transition to this page shall be performed. + + \note The PageTransition structure is owned by this page, and will + automatically be destroyed when this page class is + destroyed. + **/ + PageTransition *transition() const; + + /** + Gets the page action specified, or NULL if there is no action. + + \since 0.6 + **/ + Link *action( PageAction act ) const; + + /** + Types of orientations that are possible + */ + enum Orientation { + Landscape, ///< Landscape orientation (portrait, with 90 degrees clockwise rotation ) + Portrait, ///< Normal portrait orientation + Seascape, ///< Seascape orientation (portrait, with 270 degrees clockwise rotation) + UpsideDown ///< Upside down orientation (portrait, with 180 degrees rotation) + }; + + /** + The orientation of the page + */ + Orientation orientation() const; + + /** + The default CTM + */ + void defaultCTM(double *CTM, double dpiX, double dpiY, int rotate, bool upsideDown); + + /** + Gets the links of the page + */ + QList links() const; + + /** + Returns the annotations of the page + + \note If you call this method twice, you get different objects + pointing to the same annotations (see Annotation). + The caller owns the returned objects and they should be deleted + when no longer required. + */ + QList annotations() const; + + /** + Adds an annotation to the page + + \note Ownership of the annotation object stays with the caller, who can + delete it at any time. + \since 0.20 + */ + void addAnnotation( const Annotation *ann ); + + /** + Removes an annotation from the page and destroys the annotation object + + \note There mustn't be other Annotation objects pointing this annotation + \since 0.20 + */ + void removeAnnotation( const Annotation *ann ); + + /** + Returns the form fields on the page + The caller gets the ownership of the returned objects. + + \since 0.6 + */ + QList formFields() const; + + /** + Returns the page duration. That is the time, in seconds, that the page + should be displayed before the presentation automatically advances to the next page. + Returns < 0 if duration is not set. + + \since 0.6 + */ + double duration() const; + + /** + Returns the label of the page, or a null string is the page has no label. + + \since 0.6 + **/ + QString label() const; + + private: + Q_DISABLE_COPY(Page) + + Page(DocumentData *doc, int index); + PageData *m_page; + }; + +/** + \brief PDF document. + + The Document class represents a PDF document: its pages, and all the global + properties, metadata, etc. + + \section ownership Ownership of the returned objects + + All the functions that returns class pointers create new object, and the + responsability of those is given to the callee. + + The only exception is \link Poppler::Page::transition() Page::transition()\endlink. + + \section document-loading Loading + + To get a Document, you have to load it via the load() & loadFromData() + functions. + + In all the functions that have passwords as arguments, they \b must be Latin1 + encoded. If you have a password that is a UTF-8 string, you need to use + QString::toLatin1() (or similar) to convert the password first. + If you have a UTF-8 character array, consider converting it to a QString first + (QString::fromUtf8(), or similar) before converting to Latin1 encoding. + + \section document-rendering Rendering + + To render pages of a document, you have different Document functions to set + various options. + + \subsection document-rendering-backend Backends + + %Poppler offers a different backends for rendering the pages. Currently + there are two backends (see #RenderBackend), but only the Splash engine works + well and has been tested. + + The available rendering backends can be discovered via availableRenderBackends(). + The current rendering backend can be changed using setRenderBackend(). + Please note that setting a backend not listed in the available ones + will always result in null QImage's. + + \section document-cms Color management support + + %Poppler, if compiled with this support, provides functions to handle color + profiles. + + To know whether the %Poppler version you are using has support for color + management, you can query Poppler::isCmsAvailable(). In case it is not + avilable, all the color management-related functions will either do nothing + or return null. +*/ + class POPPLER_QT5_EXPORT Document { + friend class Page; + friend class DocumentData; + + public: + /** + The page mode + */ + enum PageMode { + UseNone, ///< No mode - neither document outline nor thumbnail images are visible + UseOutlines, ///< Document outline visible + UseThumbs, ///< Thumbnail images visible + FullScreen, ///< Fullscreen mode (no menubar, windows controls etc) + UseOC, ///< Optional content group panel visible + UseAttach ///< Attachments panel visible + }; + + /** + The page layout + */ + enum PageLayout { + NoLayout, ///< Layout not specified + SinglePage, ///< Display a single page + OneColumn, ///< Display a single column of pages + TwoColumnLeft, ///< Display the pages in two columns, with odd-numbered pages on the left + TwoColumnRight, ///< Display the pages in two columns, with odd-numbered pages on the right + TwoPageLeft, ///< Display the pages two at a time, with odd-numbered pages on the left + TwoPageRight ///< Display the pages two at a time, with odd-numbered pages on the right + }; + + /** + The render backends available + + \since 0.6 + */ + enum RenderBackend { + SplashBackend, ///< Splash backend + ArthurBackend ///< Arthur (Qt) backend + }; + + /** + The render hints available + + \since 0.6 + */ + enum RenderHint { + Antialiasing = 0x00000001, ///< Antialiasing for graphics + TextAntialiasing = 0x00000002, ///< Antialiasing for text + TextHinting = 0x00000004, ///< Hinting for text \since 0.12.1 + TextSlightHinting = 0x00000008, ///< Lighter hinting for text when combined with TextHinting \since 0.18 + OverprintPreview = 0x00000010, ///< Overprint preview \since 0.22 + ThinLineSolid = 0x00000020, ///< Enhance thin lines solid \since 0.24 + ThinLineShape = 0x00000040 ///< Enhance thin lines shape. Wins over ThinLineSolid \since 0.24 + }; + Q_DECLARE_FLAGS( RenderHints, RenderHint ) + + /** + Form types + + \since 0.22 + */ + enum FormType { + NoForm, ///< Document doesn't contain forms + AcroForm, ///< AcroForm + XfaForm ///< Adobe XML Forms Architecture (XFA), currently unsupported + }; + + /** + Set a color display profile for the current document. + + \param outputProfileA is a \c cmsHPROFILE of the LCMS library. + + \since 0.12 + */ + void setColorDisplayProfile(void *outputProfileA); + /** + Set a color display profile for the current document. + + \param name is the name of the display profile to set. + + \since 0.12 + */ + void setColorDisplayProfileName(const QString &name); + /** + Return the current RGB profile. + + \return a \c cmsHPROFILE of the LCMS library. + + \since 0.12 + */ + void* colorRgbProfile() const; + /** + Return the current display profile. + + \return a \c cmsHPROFILE of the LCMS library. + + \since 0.12 + */ + void *colorDisplayProfile() const; + + /** + Load the document from a file on disk + + \param filePath the name (and path, if required) of the file to load + \param ownerPassword the Latin1-encoded owner password to use in + loading the file + \param userPassword the Latin1-encoded user ("open") password + to use in loading the file + + \return the loaded document, or NULL on error + + \note The caller owns the pointer to Document, and this should + be deleted when no longer required. + + \warning The returning document may be locked if a password is required + to open the file, and one is not provided (as the userPassword). + */ + static Document *load(const QString & filePath, + const QByteArray &ownerPassword=QByteArray(), + const QByteArray &userPassword=QByteArray()); + + /** + Load the document from memory + + \param fileContents the file contents. They are copied so there is no need + to keep the byte array around for the full life time of + the document. + \param ownerPassword the Latin1-encoded owner password to use in + loading the file + \param userPassword the Latin1-encoded user ("open") password + to use in loading the file + + \return the loaded document, or NULL on error + + \note The caller owns the pointer to Document, and this should + be deleted when no longer required. + + \warning The returning document may be locked if a password is required + to open the file, and one is not provided (as the userPassword). + + \since 0.6 + */ + static Document *loadFromData(const QByteArray &fileContents, + const QByteArray &ownerPassword=QByteArray(), + const QByteArray &userPassword=QByteArray()); + + /** + Get a specified Page + + Note that this follows the PDF standard of being zero based - if you + want the first page, then you need an index of zero. + + The caller gets the ownership of the returned object. + + \param index the page number index + */ + Page *page(int index) const; + + /** + \overload + + + The intent is that you can pass in a label like \c "ix" and + get the page with that label (which might be in the table of + contents), or pass in \c "1" and get the page that the user + expects (which might not be the first page, if there is a + title page and a table of contents). + + \param label the page label + */ + Page *page(const QString &label) const; + + /** + The number of pages in the document + */ + int numPages() const; + + /** + The type of mode that should be used by the application + when the document is opened. Note that while this is + called page mode, it is really viewer application mode. + */ + PageMode pageMode() const; + + /** + The layout that pages should be shown in when the document + is first opened. This basically describes how pages are + shown relative to each other. + */ + PageLayout pageLayout() const; + + /** + Provide the passwords required to unlock the document + + \param ownerPassword the Latin1-encoded owner password to use in + loading the file + \param userPassword the Latin1-encoded user ("open") password + to use in loading the file + */ + bool unlock(const QByteArray &ownerPassword, const QByteArray &userPassword); + + /** + Determine if the document is locked + */ + bool isLocked() const; + + /** + The date associated with the document + + You would use this method with something like: + \code +QDateTime created = m_doc->date("CreationDate"); +QDateTime modified = m_doc->date("ModDate"); + \endcode + + The available dates are: + - CreationDate: the date of creation of the document + - ModDate: the date of the last change in the document + + \param data the type of date that is required + */ + QDateTime date( const QString & data ) const; + + /** + Get specified information associated with the document + + You would use this method with something like: + \code +QString title = m_doc->info("Title"); +QString subject = m_doc->info("Subject"); + \endcode + + In addition to \c Title and \c Subject, other information that may + be available include \c Author, \c Keywords, \c Creator and \c Producer. + + \param data the information that is required + + \sa infoKeys() to get a list of the available keys + */ + QString info( const QString & data ) const; + + /** + Obtain a list of the available string information keys. + */ + QStringList infoKeys() const; + + /** + Test if the document is encrypted + */ + bool isEncrypted() const; + + /** + Test if the document is linearised + + In some cases, this is called "fast web view", since it + is mostly an optimisation for viewing over the Web. + */ + bool isLinearized() const; + + /** + Test if the permissions on the document allow it to be + printed + */ + bool okToPrint() const; + + /** + Test if the permissions on the document allow it to be + printed at high resolution + */ + bool okToPrintHighRes() const; + + /** + Test if the permissions on the document allow it to be + changed. + + \note depending on the type of change, it may be more + appropriate to check other properties as well. + */ + bool okToChange() const; + + /** + Test if the permissions on the document allow the + contents to be copied / extracted + */ + bool okToCopy() const; + + /** + Test if the permissions on the document allow annotations + to be added or modified, and interactive form fields (including + signature fields) to be completed. + */ + bool okToAddNotes() const; + + /** + Test if the permissions on the document allow interactive + form fields (including signature fields) to be completed. + + \note this can be true even if okToAddNotes() is false - this + means that only form completion is permitted. + */ + bool okToFillForm() const; + + /** + Test if the permissions on the document allow interactive + form fields (including signature fields) to be set, created and + modified + */ + bool okToCreateFormFields() const; + + /** + Test if the permissions on the document allow content extraction + (text and perhaps other content) for accessibility usage (eg for + a screen reader) + */ + bool okToExtractForAccessibility() const; + + /** + Test if the permissions on the document allow it to be + "assembled" - insertion, rotation and deletion of pages; + or creation of bookmarks and thumbnail images. + + \note this can be true even if okToChange() is false + */ + bool okToAssemble() const; + + /** + The version of the PDF specification that the document + conforms to + + \param major an optional pointer to a variable where store the + "major" number of the version + \param minor an optional pointer to a variable where store the + "minor" number of the version + + \since 0.12 + */ + void getPdfVersion(int *major, int *minor) const; + + /** + The fonts within the PDF document. + + This is a shorthand for getting all the fonts at once. + + \note this can take a very long time to run with a large + document. You may wish to use a FontIterator if you have more + than say 20 pages + + \see newFontIterator() + */ + QList fonts() const; + + /** + Creates a new FontIterator object for font scanning. + + The new iterator can be used for reading the font information of the + document, reading page by page. + + The caller is responsible for the returned object, ie it should freed + it when no more useful. + + \param startPage the initial page from which start reading fonts + + \see fonts() + + \since 0.12 + */ + FontIterator* newFontIterator( int startPage = 0 ) const; + + /** + The font data if the font is an embedded one. + + \since 0.10 + */ + QByteArray fontData(const FontInfo &font) const; + + /** + The documents embedded within the PDF document. + + \note there are two types of embedded document - this call + only accesses documents that are embedded at the document level. + */ + QList embeddedFiles() const; + + /** + Whether there are any documents embedded in this PDF document. + */ + bool hasEmbeddedFiles() const; + + /** + Gets the table of contents (TOC) of the Document. + + The caller is responsable for the returned object. + + In the tree the tag name is the 'screen' name of the entry. A tag can have + attributes. Here follows the list of tag attributes with meaning: + - Destination: A string description of the referred destination + - DestinationName: A 'named reference' to the viewport + - ExternalFileName: A link to a external filename + - Open: A bool value that tells whether the subbranch of the item is open or not + + Resolving the final destination for each item can be done in the following way: + - first, checking for 'Destination': if not empty, then a LinkDestination + can be constructed straight with it + - as second step, if the 'DestinationName' is not empty, then the destination + can be resolved using linkDestination() + + Note also that if 'ExternalFileName' is not emtpy, then the destination refers + to that document (and not to the current one). + + \returns the TOC, or NULL if the Document does not have one + */ + QDomDocument *toc() const; + + /** + Tries to resolve the named destination \p name. + + \note this operation starts a search through the whole document + + \returns a new LinkDestination object if the named destination was + actually found, or NULL otherwise + */ + LinkDestination *linkDestination( const QString &name ); + + /** + Sets the paper color + + \param color the new paper color + */ + void setPaperColor(const QColor &color); + /** + The paper color + + The default color is white. + */ + QColor paperColor() const; + + /** + Sets the backend used to render the pages. + + \param backend the new rendering backend + + \since 0.6 + */ + void setRenderBackend( RenderBackend backend ); + /** + The currently set render backend + + The default backend is \ref SplashBackend + + \since 0.6 + */ + RenderBackend renderBackend() const; + + /** + The available rendering backends. + + \since 0.6 + */ + static QSet availableRenderBackends(); + + /** + Sets the render \p hint . + + \note some hints may not be supported by some rendering backends. + + \param on whether the flag should be added or removed. + + \since 0.6 + */ + void setRenderHint( RenderHint hint, bool on = true ); + /** + The currently set render hints. + + \since 0.6 + */ + RenderHints renderHints() const; + + /** + Gets a new PS converter for this document. + + The caller gets the ownership of the returned converter. + + \since 0.6 + */ + PSConverter *psConverter() const; + + /** + Gets a new PDF converter for this document. + + The caller gets the ownership of the returned converter. + + \since 0.8 + */ + PDFConverter *pdfConverter() const; + + /** + Gets the metadata stream contents + + \since 0.6 + */ + QString metadata() const; + + /** + Test whether this document has "optional content". + + Optional content is used to optionally turn on (display) + and turn off (not display) some elements of the document. + The most common use of this is for layers in design + applications, but it can be used for a range of things, + such as not including some content in printing, and + displaying content in the appropriate language. + + \since 0.8 + */ + bool hasOptionalContent() const; + + /** + Itemviews model for optional content. + + The model is owned by the document. + + \since 0.8 + */ + OptContentModel *optionalContentModel(); + + /** + Document-level JavaScript scripts. + + Returns the list of document level JavaScript scripts to be always + executed before any other script. + + \since 0.10 + */ + QStringList scripts() const; + + /** + The PDF identifiers. + + \param permanentId an optional pointer to a variable where store the + permanent ID of the document + \param updateId an optional pointer to a variable where store the + update ID of the document + + \return whether the document has the IDs + + \since 0.16 + */ + bool getPdfId(QByteArray *permanentId, QByteArray *updateId) const; + + /** + Returns the type of forms contained in the document + + \since 0.22 + */ + FormType formType() const; + + /** + Destructor. + */ + ~Document(); + + private: + Q_DISABLE_COPY(Document) + + DocumentData *m_doc; + + Document(DocumentData *dataA); + }; + + class BaseConverterPrivate; + class PSConverterPrivate; + class PDFConverterPrivate; + /** + \brief Base converter. + + This is the base class for the converters. + + \since 0.8 + */ + class POPPLER_QT5_EXPORT BaseConverter + { + friend class Document; + public: + /** + Destructor. + */ + virtual ~BaseConverter(); + + /** Sets the output file name. You must set this or the output device. */ + void setOutputFileName(const QString &outputFileName); + + /** + * Sets the output device. You must set this or the output file name. + * + * \since 0.8 + */ + void setOutputDevice(QIODevice *device); + + /** + Does the conversion. + + \return whether the conversion succeeded + */ + virtual bool convert() = 0; + + enum Error + { + NoError, + FileLockedError, + OpenOutputError, + NotSupportedInputFileError + }; + + /** + Returns the last error + \since 0.12.1 + */ + Error lastError() const; + + protected: + /// \cond PRIVATE + BaseConverter(BaseConverterPrivate &dd); + Q_DECLARE_PRIVATE(BaseConverter) + BaseConverterPrivate *d_ptr; + /// \endcond + + private: + Q_DISABLE_COPY(BaseConverter) + }; + + /** + Converts a PDF to PS + + Sizes have to be in Points (1/72 inch) + + If you are using QPrinter you can get paper size by doing: + \code +QPrinter dummy(QPrinter::PrinterResolution); +dummy.setFullPage(true); +dummy.setPageSize(myPageSize); +width = dummy.width(); +height = dummy.height(); + \endcode + + \since 0.6 + */ + class POPPLER_QT5_EXPORT PSConverter : public BaseConverter + { + friend class Document; + public: + /** + Options for the PS export. + + \since 0.10 + */ + enum PSOption { + Printing = 0x00000001, ///< The PS is generated for printing purposes + StrictMargins = 0x00000002, + ForceRasterization = 0x00000004, + PrintToEPS = 0x00000008, ///< Output EPS instead of PS \since 0.20 + HideAnnotations = 0x00000010 ///< Don't print annotations \since 0.20 + }; + Q_DECLARE_FLAGS( PSOptions, PSOption ) + + /** + Destructor. + */ + ~PSConverter(); + + /** Sets the list of pages to print. Mandatory. */ + void setPageList(const QList &pageList); + + /** + Sets the title of the PS Document. Optional + */ + void setTitle(const QString &title); + + /** + Sets the horizontal DPI. Defaults to 72.0 + */ + void setHDPI(double hDPI); + + /** + Sets the vertical DPI. Defaults to 72.0 + */ + void setVDPI(double vDPI); + + /** + Sets the rotate. Defaults to not rotated + */ + void setRotate(int rotate); + + /** + Sets the output paper width. Has to be set. + */ + void setPaperWidth(int paperWidth); + + /** + Sets the output paper height. Has to be set. + */ + void setPaperHeight(int paperHeight); + + /** + Sets the output right margin. Defaults to 0 + */ + void setRightMargin(int marginRight); + + /** + Sets the output bottom margin. Defaults to 0 + */ + void setBottomMargin(int marginBottom); + + /** + Sets the output left margin. Defaults to 0 + */ + void setLeftMargin(int marginLeft); + + /** + Sets the output top margin. Defaults to 0 + */ + void setTopMargin(int marginTop); + + /** + Defines if margins have to be strictly followed (even if that + means changing aspect ratio), or if the margins can be adapted + to keep aspect ratio. + + Defaults to false. + */ + void setStrictMargins(bool strictMargins); + + /** Defines if the page will be rasterized to an image before printing. Defaults to false */ + void setForceRasterize(bool forceRasterize); + + /** + Sets the options for the PS export. + + \since 0.10 + */ + void setPSOptions(PSOptions options); + + /** + The currently set options for the PS export. + + The default flags are: Printing. + + \since 0.10 + */ + PSOptions psOptions() const; + + /** + Sets a function that will be called each time a page is converted. + + The payload belongs to the caller. + + \since 0.16 + */ + void setPageConvertedCallback(void (* callback)(int page, void *payload), void *payload); + + bool convert(); + + private: + Q_DECLARE_PRIVATE(PSConverter) + Q_DISABLE_COPY(PSConverter) + + PSConverter(DocumentData *document); + }; + + /** + Converts a PDF to PDF (thus saves a copy of the document). + + \since 0.8 + */ + class POPPLER_QT5_EXPORT PDFConverter : public BaseConverter + { + friend class Document; + public: + /** + Options for the PDF export. + */ + enum PDFOption { + WithChanges = 0x00000001 ///< The changes done to the document are saved as well + }; + Q_DECLARE_FLAGS( PDFOptions, PDFOption ) + + /** + Destructor. + */ + virtual ~PDFConverter(); + + /** + Sets the options for the PDF export. + */ + void setPDFOptions(PDFOptions options); + /** + The currently set options for the PDF export. + */ + PDFOptions pdfOptions() const; + + bool convert(); + + private: + Q_DECLARE_PRIVATE(PDFConverter) + Q_DISABLE_COPY(PDFConverter) + + PDFConverter(DocumentData *document); + }; + + /** + Conversion from PDF date string format to QDateTime + */ + POPPLER_QT5_EXPORT QDateTime convertDate( char *dateString ); + + /** + Whether the color management functions are available. + + \since 0.12 + */ + POPPLER_QT5_EXPORT bool isCmsAvailable(); + + /** + Whether the overprint preview functionality is available. + + \since 0.22 + */ + POPPLER_QT5_EXPORT bool isOverprintPreviewAvailable(); + + class SoundData; + /** + Container class for a sound file in a PDF document. + + A sound can be either External (in that case should be loaded the file + whose url is represented by url() ), or Embedded, and the player has to + play the data contained in data(). + + \since 0.6 + */ + class POPPLER_QT5_EXPORT SoundObject { + public: + /** + The type of sound + */ + enum SoundType { + External, ///< The real sound file is external + Embedded ///< The sound is contained in the data + }; + + /** + The encoding format used for the sound + */ + enum SoundEncoding { + Raw, ///< Raw encoding, with unspecified or unsigned values in the range [ 0, 2^B - 1 ] + Signed, ///< Twos-complement values + muLaw, ///< mu-law-encoded samples + ALaw ///< A-law-encoded samples + }; + + /// \cond PRIVATE + SoundObject(Sound *popplersound); + /// \endcond + + ~SoundObject(); + + /** + Is the sound embedded (SoundObject::Embedded) or external (SoundObject::External)? + */ + SoundType soundType() const; + + /** + The URL of the sound file to be played, in case of SoundObject::External + */ + QString url() const; + + /** + The data of the sound, in case of SoundObject::Embedded + */ + QByteArray data() const; + + /** + The sampling rate of the sound + */ + double samplingRate() const; + + /** + The number of sound channels to use to play the sound + */ + int channels() const; + + /** + The number of bits per sample value per channel + */ + int bitsPerSample() const; + + /** + The encoding used for the sound + */ + SoundEncoding soundEncoding() const; + + private: + Q_DISABLE_COPY(SoundObject) + + SoundData *m_soundData; + }; + + class MovieData; + /** + Container class for a movie object in a PDF document. + + \since 0.10 + */ + class POPPLER_QT5_EXPORT MovieObject { + friend class AnnotationPrivate; + public: + /** + The play mode for playing the movie + */ + enum PlayMode { + PlayOnce, ///< Play the movie once, closing the movie controls at the end + PlayOpen, ///< Like PlayOnce, but leaving the controls open + PlayRepeat, ///< Play continuously until stopped + PlayPalindrome ///< Play forward, then backward, then again foward and so on until stopped + }; + + ~MovieObject(); + + /** + The URL of the movie to be played + */ + QString url() const; + + /** + The size of the movie + */ + QSize size() const; + + /** + The rotation (either 0, 90, 180, or 270 degrees clockwise) for the movie, + */ + int rotation() const; + + /** + Whether show a bar with movie controls + */ + bool showControls() const; + + /** + How to play the movie + */ + PlayMode playMode() const; + + /** + Returns whether a poster image should be shown if the movie is not playing. + \since 0.22 + */ + bool showPosterImage() const; + + /** + Returns the poster image that should be shown if the movie is not playing. + If the image is null but showImagePoster() returns @c true, the first frame of the movie + should be used as poster image. + \since 0.22 + */ + QImage posterImage() const; + + private: + /// \cond PRIVATE + MovieObject( AnnotMovie *ann ); + /// \endcond + + Q_DISABLE_COPY(MovieObject) + + MovieData *m_movieData; + }; + +} + +Q_DECLARE_OPERATORS_FOR_FLAGS(Poppler::Page::PainterFlags) +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 diff --git a/dependencies/poppler/lib/poppler-qt5.lib b/dependencies/poppler/lib/poppler-qt5.lib new file mode 100644 index 00000000..66b82cdf Binary files /dev/null and b/dependencies/poppler/lib/poppler-qt5.lib differ