PDF4QT/PdfForQtLib/sources/pdfcatalog.h

762 lines
29 KiB
C++

// Copyright (C) 2018-2020 Jakub Melka
//
// This file is part of PdfForQt.
//
// PdfForQt is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// PdfForQt 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with PDFForQt. If not, see <https://www.gnu.org/licenses/>.
#ifndef PDFCATALOG_H
#define PDFCATALOG_H
#include "pdfobject.h"
#include "pdfpage.h"
#include "pdfoptionalcontent.h"
#include "pdfoutline.h"
#include "pdfaction.h"
#include <QtCore>
#include <array>
#include <vector>
#include <utility>
namespace pdf
{
class PDFDocument;
/// Defines page layout. Default value is SinglePage. This enum specifies the page layout
/// to be used in viewer application.
enum class PageLayout
{
SinglePage, ///< Display one page at time (single page on screen)
OneColumn, ///< Displays pages in one column (continuous mode)
TwoColumnLeft, ///< Display pages in two continuous columns, odd numbered pages are on the left
TwoColumnRight, ///< Display pages in two continuous columns, even numbered pages are on the left
TwoPagesLeft, ///< Display two pages on the screen, odd numbered pages are on the left
TwoPagesRight ///< Display two pages on the screen, even numbered pages are on the left
};
/// Specifies, how the document should be displayed in the viewer application.
enum class PageMode
{
UseNone, ///< Default value, neither document outline or thumbnails are visible
UseOutlines, ///< Document outline window is selected and visible
UseThumbnails, ///< Document thumbnails window is selected and visible
Fullscreen, ///< Use fullscreen mode, no menu bars, window controls, or any other window visible (presentation mode)
UseOptionalContent, ///< Optional content group window is selected and visible
UseAttachments, ///< Attachments window is selected and visible
};
/// Represents page numbering definition object
class PDFPageLabel
{
public:
enum class NumberingStyle
{
None, ///< This means, only prefix is used, no numbering
DecimalArabic,
UppercaseRoman,
LowercaseRoman,
UppercaseLetters,
LowercaseLetters
};
explicit inline PDFPageLabel() :
m_numberingType(NumberingStyle::None),
m_prefix(),
m_pageIndex(0),
m_startNumber(0)
{
}
explicit inline PDFPageLabel(NumberingStyle numberingType, const QString& prefix, PDFInteger pageIndex, PDFInteger startNumber) :
m_numberingType(numberingType),
m_prefix(prefix),
m_pageIndex(pageIndex),
m_startNumber(startNumber)
{
}
/// Comparison operator, works only with page indices (because they should be unique)
bool operator<(const PDFPageLabel& other) const { return m_pageIndex < other.m_pageIndex; }
/// Parses page label object from PDF object, according to PDF Reference 1.7, Table 8.10
static PDFPageLabel parse(PDFInteger pageIndex, const PDFObjectStorage* storage, const PDFObject& object);
private:
NumberingStyle m_numberingType;
QString m_prefix;
PDFInteger m_pageIndex;
PDFInteger m_startNumber;
};
/// Info about the document. Title, Author, Keywords... It also stores "extra"
/// values, which are in info dictionary. They can be either strings, or date
/// time (QString or QDateTime).
struct PDFDocumentInfo
{
/// Indicates, that document was modified that it includes trapping information.
/// See PDF Reference 1.7, Section 10.10.5 "Trapping Support".
enum class Trapped
{
True, ///< Fully trapped
False, ///< Not yet trapped
Unknown ///< Either unknown, or it has been trapped partly, not fully
};
/// Parses info from catalog dictionary. If object cannot be parsed, or error occurs,
/// then exception is thrown. This function may throw exceptions, if error occured.
/// \param object Object containing info dictionary
/// \param storage Storage of objects
static PDFDocumentInfo parse(const PDFObject& object, const PDFObjectStorage* storage);
QString title;
QString author;
QString subject;
QString keywords;
QString creator;
QString producer;
QDateTime creationDate;
QDateTime modifiedDate;
Trapped trapped = Trapped::Unknown;
PDFVersion version;
std::map<QByteArray, QVariant> extra;
};
class PDFViewerPreferences
{
public:
enum OptionFlag
{
None = 0x0000, ///< Empty flag
HideToolbar = 0x0001, ///< Hide toolbar
HideMenubar = 0x0002, ///< Hide menubar
HideWindowUI = 0x0004, ///< Hide window UI (for example scrollbars, navigation controls, etc.)
FitWindow = 0x0008, ///< Resize window to fit first displayed page
CenterWindow = 0x0010, ///< Position of the document's window should be centered on the screen
DisplayDocTitle = 0x0020, ///< Display documents title instead of file name (introduced in PDF 1.4)
PickTrayByPDFSize = 0x0040, ///< Pick tray by PDF size (printing option)
EnforcePrintScaling = 0x0080 ///< Enforce print scaling settings
};
Q_DECLARE_FLAGS(OptionFlags, OptionFlag)
/// This enum specifies, how to display document, when exiting full screen mode.
enum class NonFullScreenPageMode
{
UseNone,
UseOutline,
UseThumbnails,
UseOptionalContent
};
/// Predominant reading order of text.
enum class Direction
{
LeftToRight, ///< Default
RightToLeft ///< Reading order is right to left. Also used for vertical writing systems (Chinese/Japan etc.)
};
/// Printer settings - paper handling option to use when printing the document.
enum class Duplex
{
None,
Simplex,
DuplexFlipShortEdge,
DuplexFlipLongEdge
};
enum class PrintScaling
{
None,
AppDefault
};
enum Properties
{
ViewArea,
ViewClip,
PrintArea,
PrintClip,
EndProperties
};
constexpr inline PDFViewerPreferences() = default;
constexpr inline PDFViewerPreferences(const PDFViewerPreferences&) = default;
constexpr inline PDFViewerPreferences(PDFViewerPreferences&&) = default;
constexpr inline PDFViewerPreferences& operator=(const PDFViewerPreferences&) = default;
constexpr inline PDFViewerPreferences& operator=(PDFViewerPreferences&&) = default;
/// Parses viewer preferences from catalog dictionary. If object cannot be parsed, or error occurs,
/// then exception is thrown.
static PDFViewerPreferences parse(const PDFObject& catalogDictionary, const PDFDocument* document);
OptionFlags getOptions() const { return m_optionFlags; }
const QByteArray& getProperty(Properties property) const { return m_properties.at(property); }
NonFullScreenPageMode getNonFullScreenPageMode() const { return m_nonFullScreenPageMode; }
Direction getDirection() const { return m_direction; }
Duplex getDuplex() const { return m_duplex; }
PrintScaling getPrintScaling() const { return m_printScaling; }
const std::vector<std::pair<PDFInteger, PDFInteger>>& getPrintPageRanges() const { return m_printPageRanges; }
PDFInteger getNumberOfCopies() const { return m_numberOfCopies; }
private:
OptionFlags m_optionFlags = None;
std::array<QByteArray, EndProperties> m_properties;
NonFullScreenPageMode m_nonFullScreenPageMode = NonFullScreenPageMode::UseNone;
Direction m_direction = Direction::LeftToRight;
Duplex m_duplex = Duplex::None;
PrintScaling m_printScaling = PrintScaling::AppDefault;
std::vector<std::pair<PDFInteger, PDFInteger>> m_printPageRanges;
PDFInteger m_numberOfCopies = 1;
};
/// Document security store. Contains certificates, CRLs, OCSPs, and
/// other data for signature validation.
class PDFFORQTLIBSHARED_EXPORT PDFDocumentSecurityStore
{
public:
explicit inline PDFDocumentSecurityStore() = default;
struct SecurityStoreItem
{
std::vector<QByteArray> Cert;
std::vector<QByteArray> CRL;
std::vector<QByteArray> OCSP;
QDateTime created;
QByteArray timestamp;
};
/// Returns master item. Return value is never nullptr.
const SecurityStoreItem* getMasterItem() const { return &m_master; }
/// Get item using hash. If item is not found, master item is returned.
const SecurityStoreItem* getItem(const QByteArray& hash) const;
/// Parses document security store from catalog dictionary. If object cannot be parsed, or error occurs,
/// then empty object is returned.
static PDFDocumentSecurityStore parse(const PDFObject& object, const PDFDocument* document);
private:
SecurityStoreItem m_master;
std::map<QByteArray, SecurityStoreItem> m_VRI;
};
/// Article thread. Each thread contains beads, which can be across multiple pages.
class PDFArticleThread
{
public:
explicit inline PDFArticleThread() = default;
struct Bead
{
PDFObjectReference self;
PDFObjectReference thread;
PDFObjectReference next;
PDFObjectReference previous;
PDFObjectReference page;
QRectF rect;
};
using Beads = std::vector<Bead>;
using Information = PDFDocumentInfo;
const Beads& getBeads() const { return m_beads; }
const Information& getInformation() const { return m_information; }
const PDFObjectReference& getMetadata() const { return m_metadata; }
/// Parses article thread from object. If object cannot be parsed, or error occurs,
/// then empty object is returned.
/// \param storage Storage
/// \param object Object
static PDFArticleThread parse(const PDFObjectStorage* storage, const PDFObject& object);
private:
Beads m_beads;
Information m_information;
PDFObjectReference m_metadata;
};
/// Document extensions. Contains information about developer's extensions
/// used in document.
class PDFFORQTLIBSHARED_EXPORT PDFDeveloperExtensions
{
public:
explicit PDFDeveloperExtensions() = default;
struct Extension
{
QByteArray name;
QByteArray baseVersion;
PDFInteger extensionLevel = 0;
QByteArray url;
};
using Extensions = std::vector<Extension>;
/// Returns list of extensions
const Extensions& getExtensions() const { return m_extensions; }
/// Parses extensions from catalog dictionary. If object cannot be parsed, or error occurs,
/// then empty object is returned, no exception is thrown.
/// \param object Extensions dictionary
/// \param document Document
static PDFDeveloperExtensions parse(const PDFObject& object, const PDFDocument* document);
private:
Extensions m_extensions;
};
/// Web capture info
class PDFFORQTLIBSHARED_EXPORT PDFWebCaptureInfo
{
public:
explicit PDFWebCaptureInfo() = default;
const QByteArray& getVersion() const { return m_version; }
const std::vector<PDFObjectReference>& getCommands() const { return m_commands; }
/// Parses web capture info from catalog dictionary. If object cannot be parsed, or error occurs,
/// then empty object is returned, no exception is thrown.
/// \param object Spider info dictionary
/// \param storage Storage
static PDFWebCaptureInfo parse(const PDFObject& object, const PDFObjectStorage* storage);
private:
QByteArray m_version;
std::vector<PDFObjectReference> m_commands;
};
class PDFFORQTLIBSHARED_EXPORT PDFOutputIntentICCProfileInfo
{
public:
explicit PDFOutputIntentICCProfileInfo() = default;
const QByteArray& getChecksum() const { return m_checkSum; }
const std::vector<QByteArray>& getColorants() const { return m_colorants; }
const QByteArray& getIccVersion() const { return m_iccVersion; }
const QByteArray& getSignature() const { return m_signature; }
const QString& getProfileName() const { return m_profileName; }
const PDFObject& getUrls() const { return m_urls; }
/// Parses icc profile info from object. If object cannot be parsed, or error occurs,
/// then empty object is returned, no exception is thrown.
/// \param object Output intent dictionary
/// \param storage Storage
static PDFOutputIntentICCProfileInfo parse(const PDFObject& object, const PDFObjectStorage* storage);
private:
QByteArray m_checkSum;
std::vector<QByteArray> m_colorants;
QByteArray m_iccVersion;
QByteArray m_signature;
QString m_profileName;
PDFObject m_urls;
};
/// Output intent
class PDFFORQTLIBSHARED_EXPORT PDFOutputIntent
{
public:
explicit PDFOutputIntent() = default;
const QByteArray& getSubtype() const { return m_subtype; }
const QString& getOutputCondition() const { return m_outputCondition; }
const QString& getOutputConditionIdentifier() const { return m_outputConditionIdentifier; }
const QString& getRegistryName() const { return m_registryName; }
const QString& getInfo() const { return m_info; }
const PDFObject& getOutputProfile() const { return m_destOutputProfile; }
const PDFOutputIntentICCProfileInfo& getOutputProfileInfo() const { return m_destOutputProfileRef; }
const PDFObject& getMixingHints() const { return m_mixingHints; }
const PDFObject& getSpectralData() const { return m_spectralData; }
/// Parses output intent from object. If object cannot be parsed, or error occurs,
/// then empty object is returned, no exception is thrown.
/// \param object Output intent dictionary
/// \param storage Storage
static PDFOutputIntent parse(const PDFObjectStorage* storage, const PDFObject& object);
private:
QByteArray m_subtype;
QString m_outputCondition;
QString m_outputConditionIdentifier;
QString m_registryName;
QString m_info;
PDFObject m_destOutputProfile;
PDFOutputIntentICCProfileInfo m_destOutputProfileRef;
PDFObject m_mixingHints;
PDFObject m_spectralData;
};
/// Legal attestations
class PDFFORQTLIBSHARED_EXPORT PDFLegalAttestation
{
public:
explicit inline PDFLegalAttestation() = default;
enum Entry
{
JavaScriptActions,
LaunchActions,
URIActions,
MovieActions,
SoundActions,
HideAnnotationActions,
GoToRemoteActions,
AlternateImages,
ExternalStreams,
TrueTypeFonts,
ExternalRefXobjects,
ExternalOPIdicts,
NonEmbeddedFonts,
DevDepGS_OP,
DevDepGS_HT,
DevDepGS_TR,
DevDepGS_UCR,
DevDepGS_BG,
DevDepGS_FL,
LastEntry
};
PDFInteger getEntry(Entry entry) const { return m_entries.at(entry); }
bool hasOptionalContent() const { return m_hasOptionalContent; }
const QString& getAttestationText() const { return m_attestation; }
/// Parses legal attestation from object. If object cannot be parsed, or error occurs,
/// then no object is returned, no exception is thrown.
/// \param object Legal attestation dictionary
/// \param storage Storage
static std::optional<PDFLegalAttestation> parse(const PDFObjectStorage* storage, const PDFObject& object);
private:
std::array<PDFInteger, LastEntry> m_entries = { };
bool m_hasOptionalContent = false;
QString m_attestation;
};
/// Document can contain requirements for viewer application. This class
/// verifies, if this library and viewer application satisfies these requirements
/// and returns result.
class PDFFORQTLIBSHARED_EXPORT PDFDocumentRequirements
{
public:
enum Requirement
{
None = 0x00000000,
OCInteract = 0x00000001,
OCAutoStates = 0x00000002,
AcroFormInteract = 0x00000004,
Navigation = 0x00000008,
Markup = 0x00000010,
_3DMarkup = 0x00000020,
Multimedia = 0x00000040,
U3D = 0x00000080,
PRC = 0x00000100,
Action = 0x00000200,
EnableJavaScripts = 0x00000400,
Attachment = 0x00000800,
AttachmentEditing = 0x00001000,
Collection = 0x00002000,
CollectionEditing = 0x00004000,
DigSigValidation = 0x00008000,
DigSig = 0x00010000,
DigSigMDP = 0x00020000,
RichMedia = 0x00040000,
Geospatial2D = 0x00080000,
Geospatial3D = 0x00100000,
DPartInteract = 0x00200000,
SeparationSimulation = 0x00400000,
Transitions = 0x00800000,
Encryption = 0x01000000
};
Q_DECLARE_FLAGS(Requirements, Requirement)
struct RequirementEntry
{
Requirement requirement = None;
PDFInteger penalty = 100;
QByteArray version;
PDFObject handler;
static RequirementEntry parse(const PDFObjectStorage* storage, const PDFObject& object);
};
struct ValidationResult
{
Requirements unsatisfied = None;
PDFInteger penalty = 0;
QString message;
bool isOk() const { return penalty < 100; }
bool isError() const { return !isOk(); }
bool isWarning() const { return isOk() && !message.isEmpty(); }
};
/// Validates requirements against supported requirements
ValidationResult validate(Requirements supported) const;
/// Returns string version of requirement
static QString getRequirementName(Requirement requirement);
/// Parses document requirements. If error occurs, empty
/// document requirements are returned.
/// \param storage Storage
/// \param object Object
static PDFDocumentRequirements parse(const PDFObjectStorage* storage, const PDFObject& object);
private:
std::vector<RequirementEntry> m_requirements;
};
/// Storage for page additional actions
class PDFPageAdditionalActions
{
public:
enum Action
{
Open,
Close,
End
};
inline explicit PDFPageAdditionalActions() = default;
/// Returns action for given type. If action is invalid,
/// or not present, nullptr is returned.
/// \param action Action type
const PDFAction* getAction(Action action) const { return m_actions.at(action).get(); }
/// Returns array with all actions
const std::array<PDFActionPtr, End>& getActions() const { return m_actions; }
/// Parses page additional actions from the object. If object is invalid, then
/// empty additional actions is constructed.
/// \param storage Object storage
/// \param object Additional actions object
static PDFPageAdditionalActions parse(const PDFObjectStorage* storage, PDFObject object);
private:
std::array<PDFActionPtr, End> m_actions;
};
class PDFFORQTLIBSHARED_EXPORT PDFCatalog
{
public:
constexpr inline PDFCatalog() = default;
constexpr inline PDFCatalog(const PDFCatalog&) = default;
constexpr inline PDFCatalog(PDFCatalog&&) = default;
constexpr inline PDFCatalog& operator=(const PDFCatalog&) = default;
constexpr inline PDFCatalog& operator=(PDFCatalog&&) = default;
static constexpr const size_t INVALID_PAGE_INDEX = std::numeric_limits<size_t>::max();
enum DocumentAction
{
WillClose,
WillSave,
DidSave,
WillPrint,
DidPrint,
LastDocumentAction
};
/// Returns viewer preferences of the application
const PDFViewerPreferences* getViewerPreferences() const { return &m_viewerPreferences; }
/// Returns the page count
size_t getPageCount() const { return m_pages.size(); }
/// Returns the page
const PDFPage* getPage(size_t index) const { return &m_pages.at(index); }
/// Returns page index. If page is not found, then INVALID_PAGE_INDEX is returned.
size_t getPageIndexFromPageReference(PDFObjectReference reference) const;
/// Returns optional content properties
const PDFOptionalContentProperties* getOptionalContentProperties() const { return &m_optionalContentProperties; }
/// Returns root pointer for outline items
QSharedPointer<PDFOutlineItem> getOutlineRootPtr() const { return m_outlineRoot; }
/// Returns action, which should be performed
const PDFAction* getOpenAction() const { return m_openAction.data(); }
/// Returns version of the PDF specification, to which the document conforms.
const QByteArray& getVersion() const { return m_version; }
PageLayout getPageLayout() const { return m_pageLayout; }
PageMode getPageMode() const { return m_pageMode; }
const QByteArray& getBaseURI() const { return m_baseURI; }
const std::map<QByteArray, PDFFileSpecification>& getEmbeddedFiles() const { return m_namedEmbeddedFiles; }
const PDFObject& getFormObject() const { return m_formObject; }
const PDFDeveloperExtensions& getExtensions() const { return m_extensions; }
const PDFDocumentSecurityStore& getDocumentSecurityStore() const { return m_documentSecurityStore; }
const std::vector<PDFArticleThread>& getArticleThreads() const { return m_threads; }
const PDFAction* getDocumentAction(DocumentAction action) const { return m_documentActions.at(action).get(); }
const auto& getDocumentActions() const { return m_documentActions; }
const PDFObject& getMetadata() const { return m_metadata; }
const PDFObject& getStructureTreeRoot() const { return m_structureTreeRoot; }
const QString& getLanguage() const { return m_language; }
const PDFWebCaptureInfo& getWebCaptureInfo() const { return m_webCaptureInfo; }
const std::vector<PDFOutputIntent>& getOutputIntents() const { return m_outputIntents; }
const PDFObject& getPieceInfo() const { return m_pieceInfo; }
const PDFObject& getPerms() const { return m_perms; }
const PDFLegalAttestation* getLegalAttestation() const { return m_legalAttestation.has_value() ? &m_legalAttestation.value() : nullptr; }
const PDFObject& getRequirements() const { return m_requirements; }
const PDFObject& getCollection() const { return m_collection; }
bool isXFANeedsRendering() const { return m_xfaNeedsRendering; }
const PDFObject& getAssociatedFiles() const { return m_associatedFiles; }
const PDFObject& getDocumentPartRoot() const { return m_documentPartRoot; }
const std::map<QByteArray, PDFDestination>& getNamedDestinations() const { return m_namedDestinations; }
/// Is document marked to have structure tree conforming to tagged document convention?
bool isLogicalStructureMarked() const { return m_markInfoFlags.testFlag(MarkInfo_Marked); }
/// Is document marked to have structure tree with user attributes?
bool isLogicalStructureUserPropertiesUsed() const { return m_markInfoFlags.testFlag(MarkInfo_UserProperties); }
/// Is document marked to have structure tree not completely conforming to standard?
bool isLogicalStructureSuspects() const { return m_markInfoFlags.testFlag(MarkInfo_Suspects); }
/// Returns destination using the key. If destination with the key is not found,
/// then nullptr is returned.
/// \param key Destination key
/// \returns Pointer to the destination, or nullptr
const PDFDestination* getNamedDestination(const QByteArray& key) const;
/// Returns javascript action using the key. If javascript action is not found,
/// then nullptr is returned.
/// \param key Action key
/// \returns Javascript action, or nullptr
PDFActionPtr getNamedJavaScriptAction(const QByteArray& key) const;
/// Returns appearance stream using the key. If appearance stream is not found,
/// then empty object is returned.
/// \param key Appearance stream key
/// \returns Appearance, or nullptr
PDFObject getNamedAppearanceStream(const QByteArray& key) const;
/// Returns named page using the key. If named page is not found,
/// then empty object is returned.
/// \param key Page key
/// \returns Page, or nullptr
PDFObject getNamedPage(const QByteArray& key) const;
/// Returns named template using the key. If named template is not found,
/// then empty object is returned.
/// \param key Template key
/// \returns Template, or nullptr
PDFObject getNamedTemplate(const QByteArray& key) const;
/// Returns named digital identifier using the key. If named digital identifier is not found,
/// then empty object is returned. Digital identifiers are used in Web Capture functionality.
/// See also PDF 2.0 specification.
/// \param key Digital identifier key
/// \returns Digital identifier, or nullptr
PDFObject getNamedDigitalIdentifier(const QByteArray& key) const;
/// Returns named url using the key. If named url is not found,
/// then empty object is returned. Urls are used in Web Capture functionality.
/// See also PDF 2.0 specification.
/// \param key Url key
/// \returns Url, or nullptr
PDFObject getNamedUrl(const QByteArray& key) const;
/// Returns named alternate representation using the key. If named alternate representation is not found,
/// then empty object is returned.
/// \param key Alternate representation key
/// \returns Alternate representation, or nullptr
PDFObject getNamedAlternateRepresentation(const QByteArray& key) const;
/// Returns named rendition using the key. If named rendition is not found,
/// then empty object is returned.
/// \param key Rendition key
/// \returns Rendition, or nullptr
PDFObject getNamedRendition(const QByteArray& key) const;
/// Returns all named JavaScript actions
const std::map<QByteArray, PDFActionPtr>& getNamedJavaScriptActions() const { return m_namedJavaScriptActions; }
/// Parses catalog from catalog dictionary. If object cannot be parsed, or error occurs,
/// then exception is thrown.
static PDFCatalog parse(const PDFObject& catalog, const PDFDocument* document);
private:
enum MarkInfoFlag : uint8_t
{
MarkInfo_None = 0x0000,
MarkInfo_Marked = 0x0001, ///< Document conforms to tagged PDF convention
MarkInfo_UserProperties = 0x0002, ///< Structure tree contains user properties
MarkInfo_Suspects = 0x0004, ///< Suspects
};
Q_DECLARE_FLAGS(MarkInfoFlags, MarkInfoFlag)
QByteArray m_version;
PDFViewerPreferences m_viewerPreferences;
std::vector<PDFPage> m_pages;
std::vector<PDFPageLabel> m_pageLabels;
PDFOptionalContentProperties m_optionalContentProperties;
QSharedPointer<PDFOutlineItem> m_outlineRoot;
PDFActionPtr m_openAction;
std::array<PDFActionPtr, LastDocumentAction> m_documentActions;
PageLayout m_pageLayout = PageLayout::SinglePage;
PageMode m_pageMode = PageMode::UseNone;
QByteArray m_baseURI;
PDFObject m_formObject;
PDFObject m_structureTreeRoot;
PDFDeveloperExtensions m_extensions;
PDFDocumentSecurityStore m_documentSecurityStore;
std::vector<PDFArticleThread> m_threads;
PDFObject m_metadata;
MarkInfoFlags m_markInfoFlags = MarkInfo_None;
QString m_language;
PDFWebCaptureInfo m_webCaptureInfo;
std::vector<PDFOutputIntent> m_outputIntents;
PDFObject m_pieceInfo;
PDFObject m_perms;
std::optional<PDFLegalAttestation> m_legalAttestation;
PDFObject m_requirements;
PDFObject m_collection;
bool m_xfaNeedsRendering = false;
PDFObject m_associatedFiles;
PDFObject m_documentPartRoot;
// Maps from Names dictionary
std::map<QByteArray, PDFDestination> m_namedDestinations;
std::map<QByteArray, PDFObject> m_namedAppearanceStreams;
std::map<QByteArray, PDFActionPtr> m_namedJavaScriptActions;
std::map<QByteArray, PDFObject> m_namedPages;
std::map<QByteArray, PDFObject> m_namedTemplates;
std::map<QByteArray, PDFObject> m_namedDigitalIdentifiers;
std::map<QByteArray, PDFObject> m_namedUniformResourceLocators;
std::map<QByteArray, PDFFileSpecification> m_namedEmbeddedFiles;
std::map<QByteArray, PDFObject> m_namedAlternateRepresentations;
std::map<QByteArray, PDFObject> m_namedRenditions;
};
} // namespace pdf
#endif // PDFCATALOG_H