diff options
Diffstat (limited to 'Build/source/libs/poppler/poppler-0.22.2/poppler/XRef.h')
-rw-r--r-- | Build/source/libs/poppler/poppler-0.22.2/poppler/XRef.h | 254 |
1 files changed, 254 insertions, 0 deletions
diff --git a/Build/source/libs/poppler/poppler-0.22.2/poppler/XRef.h b/Build/source/libs/poppler/poppler-0.22.2/poppler/XRef.h new file mode 100644 index 00000000000..9af4a139faa --- /dev/null +++ b/Build/source/libs/poppler/poppler-0.22.2/poppler/XRef.h @@ -0,0 +1,254 @@ +//======================================================================== +// +// XRef.h +// +// Copyright 1996-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 <bradh@frogmouth.net> +// Copyright (C) 2006, 2008, 2010-2012 Albert Astals Cid <aacid@kde.org> +// Copyright (C) 2007-2008 Julien Rebetez <julienr@svn.gnome.org> +// Copyright (C) 2007 Carlos Garcia Campos <carlosgc@gnome.org> +// Copyright (C) 2010 Ilya Gorenbein <igorenbein@finjan.com> +// Copyright (C) 2010 Hib Eris <hib@hiberis.nl> +// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@kabelmail.de> +// Copyright (C) 2012 Fabio D'Urso <fabiodurso@hotmail.it> +// +// 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 XREF_H +#define XREF_H + +#ifdef USE_GCC_PRAGMAS +#pragma interface +#endif + +#include "goo/gtypes.h" +#include "Object.h" +#include "Stream.h" + +#include <vector> + +class Dict; +class Stream; +class Parser; +class PopplerCache; + +//------------------------------------------------------------------------ +// XRef +//------------------------------------------------------------------------ + +enum XRefEntryType { + xrefEntryFree, + xrefEntryUncompressed, + xrefEntryCompressed, + xrefEntryNone +}; + +struct XRefEntry { + Guint offset; + int gen; + XRefEntryType type; + int flags; + Object obj; //if this entry was updated, obj will contains the updated object + + enum Flag { + // Regular flags + Updated, // Entry was modified + + // Special flags -- available only after xref->scanSpecialFlags() is run + Unencrypted, // Entry is stored in unencrypted form (meaningless in unencrypted documents) + DontRewrite // Entry must not be written back in case of full rewrite + }; + + inline GBool getFlag(Flag flag) { + const int mask = (1 << (int)flag); + return (flags & mask) != 0; + } + + inline void setFlag(Flag flag, GBool value) { + const int mask = (1 << (int)flag); + if (value) { + flags |= mask; + } else { + flags &= ~mask; + } + } +}; + +class XRef { +public: + + // Constructor, create an empty XRef, used for PDF writing + XRef(); + // Constructor, create an empty XRef but with info dict, used for PDF writing + XRef(Object *trailerDictA); + // Constructor. Read xref table from stream. + XRef(BaseStream *strA, Guint pos, Guint mainXRefEntriesOffsetA = 0, GBool *wasReconstructed = NULL, GBool reconstruct = false); + + // Destructor. + ~XRef(); + + // Is xref table valid? + GBool isOk() { return ok; } + + // Is the last XRef section a stream or a table? + GBool isXRefStream() { return xRefStream; } + + // Get the error code (if isOk() returns false). + int getErrorCode() { return errCode; } + + // Set the encryption parameters. + void setEncryption(int permFlagsA, GBool ownerPasswordOkA, + Guchar *fileKeyA, int keyLengthA, + int encVersionA, int encRevisionA, + CryptAlgorithm encAlgorithmA); + // Mark Encrypt entry as Unencrypted + void markUnencrypted(); + + void getEncryptionParameters(Guchar **fileKeyA, CryptAlgorithm *encAlgorithmA, int *keyLengthA); + + // Is the file encrypted? + GBool isEncrypted() { return encrypted; } + + // Check various permissions. + GBool okToPrint(GBool ignoreOwnerPW = gFalse); + GBool okToPrintHighRes(GBool ignoreOwnerPW = gFalse); + GBool okToChange(GBool ignoreOwnerPW = gFalse); + GBool okToCopy(GBool ignoreOwnerPW = gFalse); + GBool okToAddNotes(GBool ignoreOwnerPW = gFalse); + GBool okToFillForm(GBool ignoreOwnerPW = gFalse); + GBool okToAccessibility(GBool ignoreOwnerPW = gFalse); + GBool okToAssemble(GBool ignoreOwnerPW = gFalse); + int getPermFlags() { return permFlags; } + + // Get catalog object. + Object *getCatalog(Object *obj); + + // Fetch an indirect reference. + Object *fetch(int num, int gen, Object *obj, int recursion = 0); + + // Return the document's Info dictionary (if any). + Object *getDocInfo(Object *obj); + Object *getDocInfoNF(Object *obj); + + // Return the number of objects in the xref table. + int getNumObjects() { return size; } + + // Return the catalog object reference. + int getRootNum() { return rootNum; } + int getRootGen() { return rootGen; } + + // Get end position for a stream in a damaged file. + // Returns false if unknown or file is not damaged. + GBool getStreamEnd(Guint streamStart, Guint *streamEnd); + + // Retuns the entry that belongs to the offset + int getNumEntry(Guint offset); + + // Scans the document and sets special flags in all xref entries. One of those + // flags is Unencrypted, which affects how the object is fetched. Therefore, + // this function must be called before fetching unencrypted objects (e.g. + // Encrypt dictionary, XRef streams). Note that the code that initializes + // decryption doesn't need to call this function, because it runs before + // decryption is enabled, and therefore the Unencrypted flag is ignored. + void scanSpecialFlags(); + + // Direct access. + XRefEntry *getEntry(int i, GBool complainIfMissing = gTrue); + Object *getTrailerDict() { return &trailerDict; } + + // Write access + void setModifiedObject(Object* o, Ref r); + Ref addIndirectObject (Object* o); + void removeIndirectObject(Ref r); + void add(int num, int gen, Guint offs, GBool used); + + // Output XRef table to stream + void writeTableToFile(OutStream* outStr, GBool writeAllEntries); + // Output XRef stream contents to GooString and fill trailerDict fields accordingly + void writeStreamToBuffer(GooString *stmBuf, Dict *xrefDict, XRef *xref); + +private: + + BaseStream *str; // input stream + Guint start; // offset in file (to allow for garbage + // at beginning of file) + XRefEntry *entries; // xref entries + int capacity; // size of <entries> array + int size; // number of entries + int rootNum, rootGen; // catalog dict + GBool ok; // true if xref table is valid + int errCode; // error code (if <ok> is false) + Object trailerDict; // trailer dictionary + Guint *streamEnds; // 'endstream' positions - only used in + // damaged files + int streamEndsLen; // number of valid entries in streamEnds + PopplerCache *objStrs; // cached object streams + GBool encrypted; // true if file is encrypted + int encRevision; + int encVersion; // encryption algorithm + CryptAlgorithm encAlgorithm; // encryption algorithm + int keyLength; // length of key, in bytes + int permFlags; // permission bits + Guchar fileKey[32]; // file decryption key + GBool ownerPasswordOk; // true if owner password is correct + Guint prevXRefOffset; // position of prev XRef section (= next to read) + Guint mainXRefEntriesOffset; // offset of entries in main XRef table + GBool xRefStream; // true if last XRef section is a stream + Guint mainXRefOffset; // position of the main XRef table/stream + GBool scannedSpecialFlags; // true if scanSpecialFlags has been called + + void init(); + int reserve(int newSize); + int resize(int newSize); + GBool readXRef(Guint *pos, std::vector<Guint> *followedXRefStm, std::vector<int> *xrefStreamObjsNum); + GBool readXRefTable(Parser *parser, Guint *pos, std::vector<Guint> *followedXRefStm, std::vector<int> *xrefStreamObjsNum); + GBool readXRefStreamSection(Stream *xrefStr, int *w, int first, int n); + GBool readXRefStream(Stream *xrefStr, Guint *pos); + GBool constructXRef(GBool *wasReconstructed, GBool needCatalogDict = gFalse); + GBool parseEntry(Guint offset, XRefEntry *entry); + void readXRefUntil(int untilEntryNum, std::vector<int> *xrefStreamObjsNum = NULL); + void markUnencrypted(Object *obj); + + class XRefWriter { + public: + virtual void startSection(int first, int count) = 0; + virtual void writeEntry(Guint offset, int gen, XRefEntryType type) = 0; + virtual ~XRefWriter() {}; + }; + + class XRefTableWriter: public XRefWriter { + public: + XRefTableWriter(OutStream* outStrA); + void startSection(int first, int count); + void writeEntry(Guint offset, int gen, XRefEntryType type); + private: + OutStream* outStr; + }; + + class XRefStreamWriter: public XRefWriter { + public: + XRefStreamWriter(Object *index, GooString *stmBuf); + void startSection(int first, int count); + void writeEntry(Guint offset, int gen, XRefEntryType type); + private: + Object *index; + GooString *stmBuf; + }; + + void writeXRef(XRefWriter *writer, GBool writeAllEntries); +}; + +#endif |