PdfDeclarations.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2005 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_DECLARATIONS_H
#define PDF_DECLARATIONS_H
 
 
 // Include some base macro definitions
#include <podofo/auxiliary/basedefs.h>
 
// Include common system headers
#include <podofo/auxiliary/baseincludes.h>
 
#include <podofo/auxiliary/Version.h>
 
#define FORWARD_DECLARE_FCONFIG()\
extern "C" {\
    struct _FcConfig;\
    typedef struct _FcConfig FcConfig;\
}
 
#define FORWARD_DECLARE_FREETYPE()\
extern "C"\
{\
    struct FT_FaceRec_;\
    typedef struct FT_FaceRec_* FT_Face;\
}
 
namespace PoDoFo {
 
enum class PdfLogSeverity : uint8_t
{
    None = 0,            
    Error,               
    Warning,             
    Information,         
    Debug,               
};
 
// Enums
 
enum class PdfVersion : uint8_t
{
    Unknown = 0,
    V1_0 = 10,       
    V1_1 = 11,       
    V1_2 = 12,       
    V1_3 = 13,       
    V1_4 = 14,       
    V1_5 = 15,       
    V1_6 = 16,       
    V1_7 = 17,       
    V2_0 = 20,       
};
 
constexpr PdfVersion PdfVersionDefault = PdfVersion::V1_4;
 
enum class PdfALevel : uint8_t
{
    Unknown = 0,
    // ISO 19005-1:2005
    L1B,
    L1A,
    // ISO 19005-2:2011
    L2B,
    L2A,
    L2U,
    // ISO 19005-3:2012
    L3B,
    L3A,
    L3U,
    // ISO 19005-4:2020
    L4,
    L4E,
    L4F,
};
 
enum class PdfUALevel : uint8_t
{
    Unknown = 0,
    L1,         // ISO 14289-1:2014
    L2,         // ISO 14289-2:2024
};
 
enum class PdfStringCharset : uint8_t
{
    Unknown = 0,        
    Ascii,              
    PdfDocEncoding,     
    Unicode,            
};
 
enum class PdfEncodingMapType : uint8_t
{
    Indeterminate = 0,          
    Simple,                     
    CMap                        
};
 
enum class PdfPredefinedEncodingType : uint8_t
{
    Indeterminate = 0,          
    LegacyPredefined,           
    PredefinedCMap,             
    IdentityCMap,               
};
 
enum class PdfWModeKind : uint8_t
{
    Horizontal = 0,
    Vertical = 1,
};
 
enum class PdfWriteFlags
{
    None = 0,
    Clean = 1,             
    NoInlineLiteral = 2,   
    NoFlateCompress = 4,
    PdfAPreserve = 8,      
    SkipDelimiters = 16,   
};
 
enum class PdfDataType : uint8_t
{
    Unknown = 0,           
    Bool,                  
    Number,                
    Real,                  
    String,                
    Name,                  
    Array,                 
    Dictionary,            
    Null,                  
    Reference,             
    RawData,               
};
 
enum class PdfTokenType : uint8_t
{
    Unknown = 0,
    Literal,
    ParenthesisLeft,
    ParenthesisRight,
    BraceLeft,
    BraceRight,
    AngleBracketLeft,
    AngleBracketRight,
    DoubleAngleBracketsLeft,
    DoubleAngleBracketsRight,
    SquareBracketLeft,
    SquareBracketRight,
    Slash,
};
 
enum class PdfTextExtractFlags
{
    None = 0,
    IgnoreCase = 1,
    KeepWhiteTokens = 2,
    TokenizeWords = 4,
    MatchWholeWord = 8,
    RegexPattern = 16,
    ComputeBoundingBox = 32,    
    RawCoordinates = 64,
    ExtractSubstring = 128,     
};
 
enum class PdfXObjectType : uint8_t
{
    Unknown = 0,
    Form,
    Image,
    PostScript,
};
 
enum class PdfFilterType : uint8_t
{
    None = 0,                  
    ASCIIHexDecode,            
    ASCII85Decode,             
    LZWDecode,
    FlateDecode,               
    RunLengthDecode,           
    CCITTFaxDecode,
    JBIG2Decode,
    DCTDecode,
    JPXDecode,
    Crypt
};
 
enum class PdfExportFormat : uint8_t
{
    Png = 1,        
    Jpeg = 2,
};
 
enum class PdfFontDescriptorFlags : uint32_t
{
    None        = 0,
    FixedPitch  = 1 << 0, 
    Serif       = 1 << 1,
    Symbolic    = 1 << 2, 
    Script      = 1 << 3,
    NonSymbolic = 1 << 5, 
    Italic      = 1 << 6, 
    AllCap      = 1 << 16,
    SmallCap    = 1 << 17,
    ForceBold   = 1 << 18, 
};
 
enum class PdfFontStretch : uint8_t
{
    Unknown = 0,
    UltraCondensed,
    ExtraCondensed,
    Condensed,
    SemiCondensed,
    Normal,
    SemiExpanded,
    Expanded,
    ExtraExpanded,
    UltraExpanded,
};
 
enum class PdfFontType : uint8_t
{
    Unknown = 0,
    Type1,
    Type3,
    TrueType,
    CIDCFF,      
    CIDTrueType, 
};
 
enum class PdfFontFileType : uint8_t
{
    // Table 126 – Embedded font organization for various font types
    Unknown = 0,
    Type1,
    Type1CFF,       
    CIDKeyedCFF,    
    Type3,
    TrueType,       
    OpenTypeCFF     
};
 
enum class PdfFontStyle : uint8_t
{
    None = 0,
    Italic = 1,
    Bold = 2,
    // Alias to represent a font with regular style
    Regular = None,
};
 
enum class PdfGlyphAccess : uint8_t
{
    ReadMetrics = 1,   
    FontProgram = 2    
};
 
enum class PdfFontAutoSelectBehavior : uint8_t
{
    None = 0,                   
    Standard14 = 1,             
    Standard14Alt = 2,          
};
 
enum class PdfFontCreateFlags
{
    None = 0,                 
    DontEmbed = 1,            
    DontSubset = 2,           
    PreferNonCID = 4,         
};
 
enum class PdfFontMatchBehaviorFlags : uint8_t
{
    None,
    NormalizePattern = 1,         
    SkipMatchPostScriptName = 2,  
};
 
enum class PdfColorSpaceType : uint8_t
{
    Unknown = 0,
    DeviceGray,
    DeviceRGB,
    DeviceCMYK,
    CalGray,
    CalRGB,
    Lab,            
    ICCBased,
    Indexed,
    Pattern,
    Separation,
    DeviceN
};
 
enum class PdfPixelFormat : uint8_t
{
    Unknown = 0,
    Grayscale,
    RGB24,
    BGR24,
    RGBA,           
    BGRA,           
    ARGB,
    ABGR,           
};
 
enum class PdfTextRenderingMode : uint8_t
{
    Fill = 0,                  
    Stroke,                    
    FillStroke,                
    Invisible,                 
    FillAddToClipPath,         
    StrokeAddToClipPath,       
    FillStrokeAddToClipPath,   
    AddToClipPath,             
};
 
enum class PdfStrokeStyle : uint8_t
{
    Solid = 1,
    Dash,
    Dot,
    DashDot,
    DashDotDot
};
 
enum class PdfInfoInitial : uint8_t
{
    None = 0,
    WriteCreationTime = 1,      
    WriteModificationTime = 2,  
    WriteProducer = 4,          
};
 
enum class PdfLineCapStyle : uint8_t
{
    Butt = 0,
    Round = 1,
    Square = 2
};
 
enum class PdfLineJoinStyle : uint8_t
{
    Miter = 0,
    Round = 1,
    Bevel = 2
};
 
enum class PdfVerticalAlignment : uint8_t
{
    Top = 0,
    Center = 1,
    Bottom = 2
};
 
enum class PdfHorizontalAlignment : uint8_t
{
    Left = 0,
    Center = 1,
    Right = 2
};
 
enum class PdfSaveOptions : uint32_t
{
    None = 0,
 
    ForceXRefTable = 1,
 
    ForceXRefStream = 2,
 
    NoFlateCompress = 4,
    NoCollectGarbage = 8,
    NoMetadataUpdate = 16,
    Clean = 32,
    SaveOnSigning = 64,
 
    IgnoreXRefErrors = 128,
 
    NoModifyDateUpdate = NoMetadataUpdate
};
 
enum class PdfLoadOptions : uint32_t
{
    None = 0,
    StrictParsing = 1,
    LoadStreamsEagerly = 2,
    SkipXRefRecovery = 4,
};
 
enum class PdfAdditionalMetadata : uint8_t
{
    PdfAIdAmd = 1,
    PdfAIdCorr,
    PdfAIdRev,
    PdfUAIdAmd,
    PdfUAIdCorr,
    PdfUAIdRev,
};
 
enum class PdfPageSize : uint8_t
{
    Unknown = 0,
    A0,              
    A1,              
    A2,              
    A3,              
    A4,              
    A5,              
    A6,              
    Letter,          
    Legal,           
    Tabloid,         
};
 
enum class PdfPageMode : uint8_t
{
    UseNone = 1,
    UseThumbs,
    UseOutlines,
    FullScreen,
    UseOC,
    UseAttachments
};
 
enum class PdfPageLayout : uint8_t
{
    SinglePage = 1,
    OneColumn,
    TwoColumnLeft,
    TwoColumnRight,
    TwoPageLeft,
    TwoPageRight
};
 
enum class PdfStandard14FontType : uint8_t
{
    Unknown = 0,
    TimesRoman,
    TimesItalic,
    TimesBold,
    TimesBoldItalic,
    Helvetica,
    HelveticaOblique,
    HelveticaBold,
    HelveticaBoldOblique,
    Courier,
    CourierOblique,
    CourierBold,
    CourierBoldOblique,
    Symbol,
    ZapfDingbats,
};
 
enum class PdfAnnotationType : uint8_t
{
    Unknown = 0,
    Text,                       // - supported
    Link,                       // - supported
    FreeText,       // PDF 1.3  // - supported
    Line,           // PDF 1.3  // - supported
    Square,         // PDF 1.3
    Circle,         // PDF 1.3
    Polygon,        // PDF 1.5
    PolyLine,       // PDF 1.5
    Highlight,      // PDF 1.3
    Underline,      // PDF 1.3
    Squiggly,       // PDF 1.4
    StrikeOut,      // PDF 1.3
    Stamp,          // PDF 1.3
    Caret,          // PDF 1.5
    Ink,            // PDF 1.3
    Popup,          // PDF 1.3  // - supported
    FileAttachement,// PDF 1.3
    Sound,          // PDF 1.2
    Movie,          // PDF 1.2
    Widget,         // PDF 1.2  // - supported
    Screen,         // PDF 1.5
    PrinterMark,    // PDF 1.4
    TrapNet,        // PDF 1.3
    Watermark,      // PDF 1.6
    Model3D,        // PDF 1.6
    RichMedia,      // PDF 1.7 ADBE ExtensionLevel 3 ALX: Petr P. Petrov
    WebMedia,       // PDF 1.7 IPDF ExtensionLevel 3
    Redact,         // PDF 1.7
    Projection,     // PDF 2.0
};
 
enum class PdfAnnotationFlags : uint32_t
{
    None = 0x0000,
    Invisible = 0x0001,
    Hidden = 0x0002,
    Print = 0x0004,
    NoZoom = 0x0008,
    NoRotate = 0x0010,
    NoView = 0x0020,
    ReadOnly = 0x0040,
    Locked = 0x0080,
    ToggleNoView = 0x0100,
    LockedContents = 0x0200,
};
 
enum class PdfFieldType : uint32_t
{
    Unknown = 0,
    PushButton,
    CheckBox,
    RadioButton,
    TextBox,
    ComboBox,
    ListBox,
    Signature,
};
 
enum class PdfHighlightingMode : uint8_t
{
    Unknown = 0,
    None,           
    Invert,         
    InvertOutline,  
    Push,           
};
 
enum class PdfFieldFlags : uint8_t
{
    ReadOnly = 1,
    Required = 2,
    NoExport = 4
};
 
enum class PdfAppearanceType : uint8_t
{
    Normal = 0, 
    Rollover,   
    Down        
};
 
enum class PdfResourceType : uint8_t
{
    Unknown = 0,
    ExtGState,
    ColorSpace,
    Pattern,
    Shading,
    XObject,
    Font,
    Properties
};
 
enum class PdfKnownNameTree : uint8_t
{
    Unknown = 0,
    Dests,
    AP,
    JavaScript,
    Pages,
    Templates,
    IDS,
    URLS,
    EmbeddedFiles,
    AlternatePresentations,
    Renditions,
};
 
enum class PdfOperator : uint8_t
{
    Unknown = 0,
    // ISO 32008-1:2008 Table 51 – Operator Categories
    // General graphics state
    w,
    J,
    j,
    M,
    d,
    ri,
    i,
    gs,
    // Special graphics state
    q,
    Q,
    cm,
    // Path construction
    m,
    l,
    c,
    v,
    y,
    h,
    re,
    // Path painting
    S,
    s,
    f,
    F,
    f_Star,
    B,
    B_Star,
    b,
    b_Star,
    n,
    // Clipping paths
    W,
    W_Star,
    // Text objects
    BT,
    ET,
    // Text state
    Tc,
    Tw,
    Tz,
    TL,
    Tf,
    Tr,
    Ts,
    // Text positioning
    Td,
    TD,
    Tm,
    T_Star,
    // Text showing
    Tj,
    TJ,
    Quote,
    DoubleQuote,
    // Type 3 fonts
    d0,
    d1,
    // Color
    CS,
    cs,
    SC,
    SCN,
    sc,
    scn,
    G,
    g,
    RG,
    rg,
    K,
    k,
    // Shading patterns
    sh,
    // Inline images
    BI,
    ID,
    EI,
    // XObjects
    Do,
    // Marked content
    MP,
    DP,
    BMC,
    BDC,
    EMC,
    // Compatibility
    BX,
    EX,
};
 
enum class PdfRenderingIntent : uint8_t
{
    Unknown = 0,
    AbsoluteColorimetric,
    RelativeColorimetric,
    Perceptual,
    Saturation,
};
 
enum class PdfBlendMode : uint8_t
{
    Unknown = 0,
    Normal,
    Multiply,
    Screen,
    Overlay,
    Darken,
    Lighten,
    ColorDodge,
    ColorBurn,
    HardLight,
    SoftLight,
    Difference,
    Exclusion,
    Hue,
    Saturation,
    Color,
    Luminosity,
};
 
enum class PdfSignatureType : uint8_t
{
    Unknown = 0,
    PAdES_B = 1,
    Pkcs7 = 2,
};
 
enum class [[deprecated("Use PdfSigningAlgorithm instead")]] PdfSignatureEncryption : uint8_t
{
    Unknown = 0,
    RSA,
    ECDSA,
};
 
enum class PdfSigningAlgorithm : uint8_t
{
    Unknown = 0,
    RSA,
    DSA,
    ECDSA,
    ML_DSA,
    SLH_DSA,
};
 
enum class PdfHashingAlgorithm : uint8_t
{
    Unknown = 0,
    SHA256,
    SHA384,
    SHA512,
};
 
using PdfFilterList = std::vector<PdfFilterType>;
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfSaveOptions);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfLoadOptions);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfWriteFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfInfoInitial);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfFontStyle);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfFontCreateFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfFontAutoSelectBehavior);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfFontMatchBehaviorFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfFontDescriptorFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfGlyphAccess);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfTextExtractFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfAnnotationFlags);
 
 
#endif // PDF_DECLARATIONS_H