PdfContentStreamReader.h

 
#ifndef PDF_CONTENT_READER_H
#define PDF_CONTENT_READER_H
 
#include "PdfXObject.h"
#include "PdfCanvas.h"
#include "PdfData.h"
#include "PdfDictionary.h"
#include "PdfVariantStack.h"
#include "PdfPostScriptTokenizer.h"
 
namespace PoDoFo {
 
enum class PdfContentType
{
    Unknown = 0,
    Operator,          
    ImageDictionary,   
    ImageData,         
    DoXObject,         
    BeginFormXObject,  
    EndFormXObject,    
    UnexpectedKeyword, 
};
 
enum class PdfContentWarnings
{
    None = 0,
    InvalidOperator = 1,                
    SpuriousStackContent = 2,           
    InvalidXObject = 4,                 
    RecursiveXObject = 8,               
    InvalidImageDictionaryContent = 16, 
    MissingEndImage = 32,               
};
 
struct PODOFO_API PdfContent final
{
    PdfContentType Type = PdfContentType::Unknown;
    PdfContentWarnings Warnings = PdfContentWarnings::None;
    PdfVariantStack Stack;
    PdfOperator Operator = PdfOperator::Unknown;
    std::string_view Keyword;
    PdfDictionary InlineImageDictionary;
    charbuff InlineImageData;
    const PdfName* Name = nullptr;
    std::shared_ptr<const PdfXObject> XObject;
};
 
enum class PdfContentReaderFlags
{
    None = 0,
    ThrowOnWarnings = 1,
    SkipFollowFormXObjects = 2,     
    SkipHandleNonFormXObjects = 4,  
};
 
using PdfInlineImageHandler = std::function<bool(const PdfDictionary& imageDict, InputStreamDevice& device)>;
 
struct PODOFO_API PdfContentReaderArgs final
{
    PdfContentReaderFlags Flags = PdfContentReaderFlags::None;
    PdfInlineImageHandler InlineImageHandler;
};
 
class PODOFO_API PdfContentStreamReader final
{
public:
    PdfContentStreamReader(const PdfCanvas& canvas, nullable<const PdfContentReaderArgs&> args = { });
 
    PdfContentStreamReader(const std::shared_ptr<InputStreamDevice>& device, nullable<const PdfContentReaderArgs&> args = { });
 
private:
    PdfContentStreamReader(const std::shared_ptr<InputStreamDevice>& device, const PdfCanvas* canvas,
        nullable<const PdfContentReaderArgs&> args);
 
public:
    bool TryReadNext(PdfContent& data);
 
private:
    void beforeReadReset(PdfContent& content);
 
    void afterReadClear(PdfContent& content);
 
    bool tryReadNextContent(PdfContent& content);
 
    bool tryHandleOperator(PdfContent& content, bool& eof);
 
    bool tryReadInlineImgDict(PdfContent& content);
 
    bool tryReadInlineImgData(charbuff& data);
 
    bool tryHandleXObject(PdfContent& content);
 
    void handleWarnings();
 
    bool isCalledRecursively(const PdfObject* xobj);
 
private:
    struct Storage
    {
        PdfPostScriptTokenType PsType;
        std::string_view Keyword;
        PdfVariant Variant;
        PdfName Name;
    };
 
    struct Input
    {
        std::shared_ptr<const PdfXObject> Form;
        std::shared_ptr<InputStreamDevice> Device;
        const PdfCanvas* Canvas;
    };
 
private:
    std::vector<Input> m_inputs;
    PdfContentReaderArgs m_args;
    std::shared_ptr<charbuff> m_buffer;
    PdfPostScriptTokenizer m_tokenizer;
    bool m_readingInlineImgData;  // A state of reading inline image data
 
    // Temp storage
    Storage m_temp;
};
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfContentReaderFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfContentWarnings);
 
#endif // PDF_CONTENT_READER_H