content.h

Go to the documentation of this file.

// Copyright (c) 2009-2025 Avanquest Software. All rights reserved.
 
#ifndef PDFSDK_CORE_CONTENT_H_INCLUDED_
#define PDFSDK_CORE_CONTENT_H_INCLUDED_

 
#include <pdfsdk/core/api_macro.h>
#include <pdfsdk/core/document.h>
#include <pdfsdk/core/fonts.h>
#include <pdfsdk/core/objects.h>
#include <pdfsdk/core/optional_content.h>
#include <pdfsdk/errors.h>
#include <pdfsdk/math_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef void(PDFSDK_CALLCONV* PDPageLoadedProc)(size_t iPage, void* clientData);
typedef void(PDFSDK_CALLCONV* PDPageContentChangedProc)(size_t iPage, const PDRectF* rects, size_t numRects, void* clientData);
 
typedef struct PDEFunctionRec_* PDEFunction;
typedef struct PDEColorRec_* PDEColor;
typedef struct PDEClipRec_* PDEClip;
 
typedef struct {
    float low;
    float high;
} PDENumRange;
 
//----------------------------------------------------------
// Soft mask
typedef struct PDESoftMaskRec_* PDESoftMask;

typedef enum {
    kPDESoftMaskAlpha,      
    kPDESoftMaskLuminosity, 
} PDESoftMaskSubtype;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Graphics state
typedef struct PDEGStateRec_* PDEGState;

typedef enum {
    kPDELineCapButt = 0,    
    kPDELineCapRound = 1,   
    kPDELineCapSquare = 2   
} PDELineCap;

typedef enum {
    kPDELineJoinMiter = 0,  
    kPDELineJoinRound = 1,  
    kPDELineJoinBevel = 2   
} PDELineJoin;

typedef enum {
    kPDEBlendModeNormal,        
    kPDEBlendModeMultiply,      
    kPDEBlendModeScreen,        
    kPDEBlendModeOverlay,       
    kPDEBlendModeDarken,        
    kPDEBlendModeLighten,       
    kPDEBlendModeColorDodge,    
    kPDEBlendModeColorBurn,     
    kPDEBlendModeHardLight,     
    kPDEBlendModeSoftLight,     
    kPDEBlendModeDifference,    
    kPDEBlendModeExclusion,     
    kPDEBlendModeHue,           
    kPDEBlendModeSaturation,    
    kPDEBlendModeColor,         
    kPDEBlendModeLuminosity     
} PDEBlendMode;

typedef enum {
    kPDERenderingIntentPerceptual,              
    kPDERenderingIntentRelativeColorimetric,    
    kPDERenderingIntentSaturation,              
    kPDERenderingIntentAbsoluteColorimetric     
} PDERenderingIntent;
 
#define kPDEDashMaxPatternSize 15
 
typedef struct {
    size_t patternSize;
    float pattern[kPDEDashMaxPatternSize];
    float phase;
} PDEDash;

enum {
    kPDEGStateHasFillColorSpace = 0x1,        
    kPDEGStateHasFillColorComponents = 0x2,   
    kPDEGStateHasStrokeColorSpace = 0x4,      
    kPDEGStateHasStrokeColorComponents = 0x8, 
    kPDEGStateHasLineWidth = 0x10,            
    kPDEGStateHasMiterLimit = 0x20,           
    kPDEGStateHasLineCap = 0x40,              
    kPDEGStateHasLineJoin = 0x80,             
    kPDEGStateHasDash = 0x100,                
    kPDEGStateHasIntent = 0x200,              
    kPDEGStateHasStrokeAdjustment = 0x400,    
    kPDEGStateHasBlendMode = 0x800,           
    kPDEGStateHasSoftMask = 0x1000,           
    kPDEGStateHasFillAlpha = 0x2000,          
    kPDEGStateHasStrokeAlpha = 0x4000,        
    kPDEGStateHasAlphaIsShape = 0x8000,       
    kPDEGStateHasFillOverprint = 0x10000,     
    kPDEGStateHasStrokeOverprint = 0x20000,   
    kPDEGStateHasOverprintMode = 0x40000,     
    kPDEGStateHasFlatness = 0x80000,          
    kPDEGStateHasSmoothness = 0x100000        
};
typedef uint32_t PDEGStateFlags;
//----------------------------------------------------------
 
typedef struct PDEContentRec_* PDEContent;
 
//----------------------------------------------------------
// Content element
typedef struct PDEElementRec_* PDEElement;

typedef enum {
    kPDEElementUnknown,
    kPDEElementContainer,
    kPDEElementPlace,
    kPDEElementPath,
    kPDEElementText,
    kPDEElementInlineImage,
    kPDEElementXObject,
    kPDEElementShading
} PDEElementType;
//----------------------------------------------------------

typedef enum {
    kPDEFontToUnicodeCheckNotEmpty = 0,                   
    kPDEFontToUnicodeCheckOversizedBlocks = 1 << 0,       
    kPDEFontToUnicodeCheckBfrangeCrossFirstByte = 1 << 1, 
    kPDEFontToUnicodeCheckBfrangeDestOverflow = 1 << 2,   
    kPDEFontToUnicodeCheckInvalid = 1 << 3,               
    kPDEFontToUnicodeCheckPUA = 1 << 4,                   
    kPDEFontToUnicodeCheckAll = (kPDEFontToUnicodeCheckNotEmpty | kPDEFontToUnicodeCheckOversizedBlocks |
                                    kPDEFontToUnicodeCheckBfrangeCrossFirstByte | kPDEFontToUnicodeCheckBfrangeDestOverflow |
                                 kPDEFontToUnicodeCheckInvalid | kPDEFontToUnicodeCheckPUA) 
} PDEFontToUnicodeCheckFlagsBits;
 
typedef uint32_t PDEFontToUnicodeCheckFlags;

typedef enum {
    kPDEFontToUnicodeCreateDefault = 0,            
    kPDEFontToUnicodeCreateFilterInvalid = 1 << 0, 
    kPDEFontToUnicodeCreateFilterPUA = 1 << 1,     
    kPDEFontToUnicodeCreateAllowFallbacks = 1 << 2, 
} PDEFontToUnicodeCreateFlagsBits;
 
typedef uint32_t PDEFontToUnicodeCreateFlags;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Vector path
// return true if enumeration is complete
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathMoveToProc)(void* clientData, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathLineToProc)(void* clientData, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathCurveToProc)(void* clientData, const PDPointF* c1, const PDPointF* c2, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathVCurveToProc)(void* clientData, const PDPointF* c, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathYCurveToProc)(void* clientData, const PDPointF* c, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathRectProc)(void* clientData, const PDRectF* rect);
typedef PDErrCode(PDFSDK_CALLCONV* PDEPathCloseProc)(void* clientData);
 
typedef struct {
    PDEPathMoveToProc moveTo;
    PDEPathLineToProc lineTo;
    PDEPathCurveToProc curveTo;
    PDEPathVCurveToProc vCurveTo;
    PDEPathYCurveToProc yCurveTo;
    PDEPathRectProc rect;
    PDEPathCloseProc close;
} PDEPathEnumMonitor;

typedef enum {
    kPDEPathMoveTo,     
    kPDEPathLineTo,     
    kPDEPathCurveTo,    
    kPDEPathVCurveTo,   
    kPDEPathYCurveTo,   
    kPDEPathRect,       
    kPDEPathClose       
} PDEPathSegmentOp;
 
typedef struct {
    PDEPathSegmentOp op;
    float x0, y0;
    float x1, y1;
    float x2, y2;
} PDEPathSegment;

enum {
    kPDEPaintInvisible = 0x00,  
    kPDEPaintStroke = 0x01,     
    kPDEPaintFill = 0x02,       
    kPDEPaintEOFill = 0x04,     
};
typedef int PDEPaintOp;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Text
 
typedef struct PDETextItemRec_* PDETextItem;

enum {
    kPDETextRenderFill = 0x00,          
    kPDETextRenderStroke = 0x01,        
    kPDETextRenderFillAndStroke = 0x02, 
    kPDETextRenderInvisible = 0x03,     
};
 
enum {
    kPDETextRenderClipMask = 0x04       
};
 
typedef uint32_t PDETextRenderMode;
 
struct PDETextState {
    float charSpacing;
    float wordSpacing;
    float horzScaling;
    float leading;
    float textRise;
    PDETextRenderMode textRenderMode;
    bool textKnockout;
};
 
typedef wchar_t UnicodeChar;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Color space
typedef struct PDEColorSpaceRec_* PDEColorSpace;

typedef enum {
    kPDEColorSpaceDeviceGray,   
    kPDEColorSpaceDeviceRGB,    
    kPDEColorSpaceDeviceCMYK,   
    kPDEColorSpaceCalGray,      
    kPDEColorSpaceCalRGB,       
    kPDEColorSpaceLab,          
    kPDEColorSpaceICCBased,     
    kPDEColorSpaceIndexed,      
    kPDEColorSpacePattern,      
    kPDEColorSpaceSeparation,   
    kPDEColorSpaceDeviceN       
} PDEColorSpaceFamily;
 
typedef struct {
    float x;
    float y;
    float z;
} PDECieXYZ;
 
typedef struct {
    PDECieXYZ red;
    PDECieXYZ green;
    PDECieXYZ blue;
} PDECieXYZTriple;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Pattern
typedef struct PDEPatternRec_* PDEPattern;

typedef enum {
    kPDEPatternTiling = 1,  
    kPDEPatternShading = 2  
} PDEPatternType;

typedef enum {
    kPDETilingPatternPaintColored = 1,  
    kPDETilingPatternPaintUncolored = 2 
} PDETilingPatternPaintType;

typedef enum {
    kPDETilingPatternTilingConstSpacing = 1,    
    kPDETilingPatternTilingDoNotDistort = 2,    
    kPDETilingPatternTilingFast = 3             
} PDETilingPatternTilingType;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Shading
typedef struct PDEShadingRec_* PDEShading;

typedef enum {
    kPDEShadingFunctionBased = 1,       
    kPDEShadingAxial = 2,               
    kPDEShadingRadial = 3,              
    kPDEShadingFreeFormGouraud = 4,     
    kPDEShadingLatticeFormGouraud = 5,  
    kPDEShadingCoonsPatchMesh = 6,      
    kPDEShadingTensorPatchMesh = 7      
} PDEShadingType;
//----------------------------------------------------------
 
//----------------------------------------------------------
// XObject
typedef struct PDEXObjectRec_* PDEXObject;

typedef enum {
    kPDEXObjectForm,        
    kPDEXObjectImage,       
    kPDEXObjectPostScript,  
    kPDEXObjectUnknown      
} PDEXObjectType;
 
typedef struct PDEXGroupRec_* PDEXGroup;

enum {
    kPDEXGroupIsolated = 0x01,  
    kPDEXGroupKnockout = 0x02   
};
typedef uint8_t PDEXGroupFlags;
 
typedef struct {
    bool imageMask;
    int width;
    int height;
    int bitsPerComponent;
} PDEImageAttrs;
//----------------------------------------------------------
 
//----------------------------------------------------------
// Font
typedef struct PDEFontRec_* PDEFont;

typedef enum {
    kPDEFontType1,      
    kPDEFontMMType1,    
    kPDEFontTrueType,   
    kPDEFontType3,      
    kPDEFontType0       
} PDEFontSubtype;

typedef enum {
    kPDEFontFileFormatNone,          
    kPDEFontFileFormatType1,         
    kPDEFontFileFormatTrueType,      
    kPDEFontFileFormatType1C,        
    kPDEFontFileFormatCIDFontType0C, 
    kPDEFontFileFormatOpenType,      
} PDEFontFileFormat;

enum {
    kPDEFontFlagsFixedPitch = 1 << 0,   
    kPDEFontFlagsSerif = 1 << 1,        
    kPDEFontFlagsSymbolic = 1 << 2,     
    kPDEFontFlagsScript = 1 << 3,       
    kPDEFontFlagsNonsymbolic = 1 << 5,  
    kPDEFontFlagsItalic = 1 << 6,       
    kPDEFontFlagsAllCap = 1 << 16,      
    kPDEFontFlagsSmallCap = 1 << 17,    
    kPDEFontFlagsForceBold = 1 << 18    
};
 
typedef uint32_t PDEFontFlags;
 
typedef struct {
    PDEFontFlags flags;
    PDRectF fontBBox;
    int16_t missingWidth;
    int16_t stemV;
    int16_t stemH;
    int16_t capHeight;
    int16_t xHeight;
    int16_t ascent;
    int16_t descent;
    int16_t leading;
    int16_t maxWidth;
    int16_t avgWidth;
    int16_t italicAngle;
} PDEFontMetrics;

typedef struct {
    bool useCacheDevice;  
    PDPointF widths;      
    PDRectF bbox;         
} PDEType3GlyphInfo;

typedef enum {
    kPDECIDFontType0,   
    kPDECIDFontType2,   
} PDECIDFontType;

typedef struct {
    PDAtom registry;
    PDAtom ordering;
    int supplement;
} PDECIDSystemInfo;

typedef struct {
    float wy;   
    float vx;   
    float vy;   
} PDEGlyphVertMetric;

typedef enum {
    kPDEWritingModeHorz = 0x00, 
    kPDEWritingModeVert = 0x01  
} PDEWritingMode;

typedef enum {
    kPDEFontFauxNone,           
    kPDEFontFauxOriginal,       
    kPDEFontFauxSystemMatch,    
    kPDEFontFauxSystemFaux,     
    kPDEFontFauxStandardFaux,   
    kPDEFontFauxClientMatch,    
} PDEFontFauxType;
 
typedef enum {
    kPDEFontCreateEmbedded = 1 << 0, 
 
    kPDEFontCreateNeedSubset = 1 << 1, 
 
    kPDEFontCreateFlagsDefault = kPDEFontCreateEmbedded | kPDEFontCreateNeedSubset 
} PDEFontCreateFlagsBits;
 
typedef uint32_t PDEFontCreateFlags;
 
typedef PDErrCode(PDFSDK_CALLCONV* PDEOutlineMoveToProc)(void* clientData, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEOutlineLineToProc)(void* clientData, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEOutlineConicCurveToProc)(void* clientData, const PDPointF* c, const PDPointF* to);
typedef PDErrCode(PDFSDK_CALLCONV* PDEOutlineCubicCurveToProc)(void* clientData, const PDPointF* c1, const PDPointF* c2, const PDPointF* to);
 
typedef struct {
    PDEOutlineMoveToProc moveTo;
    PDEOutlineLineToProc lineTo;
    PDEOutlineConicCurveToProc conicCurveTo;
    PDEOutlineCubicCurveToProc cubicCurveTo;
} PDEOutlineEnumMonitor;

typedef enum {
    kPDETextAlignLeft,      
    kPDETextAlignCenter,    
    kPDETextAlignRight,     
    kPDETextAlignJustify,   
    kPDETextAlignBoth,      
} PDETextAlign;
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocAttachPageLoadedCallback(PDDoc doc, PDPageLoadedProc proc, void* clientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocDetachPageLoadedCallback(PDDoc doc, PDPageLoadedProc proc, void* clientData);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocAttachPageContentChangedCallback(PDDoc doc, PDPageContentChangedProc proc, void* clientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocDetachPageContentChangedCallback(PDDoc doc, PDPageContentChangedProc proc, void* clientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocNotifyPageContentChanged(PDDoc doc, size_t iPage, const PDRectF* rects, size_t numRects);
 
//----------------------------------------------------------
// Content
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDPageGetContent(PDPage page, PDEContent* pContent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDPageIsContentLoaded(PDPage page, bool* pLoaded);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateContent(PDEContent* pContent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContentGetNumElements(PDEContent content, size_t* pNumElements);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContentGetElement(PDEContent content, size_t index, PDEElement* pElement);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContentInsertElement(PDEContent content, size_t index, PDEElement element);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContentRemoveElement(PDEContent content, size_t index);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Element
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementCopy(PDEElement element, PDEElement* pCopy);
PDF_CORE_API bool PDFSDK_CALLCONV PDEElementEqual(PDEElement elementA, PDEElement elementB);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementGetType(PDEElement element, PDEElementType* pType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementGetBBox(PDEElement element, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementGetQuad(PDEElement element, PDQuad* pQuad);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementGetClip(PDEElement element, PDEClip* pClip);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementSetClip(PDEElement element, PDEClip clip);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementGetGState(PDEElement element, PDEGState* pState);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementSetGState(PDEElement element, PDEGState state);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementGetMatrix(PDEElement element, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementSetMatrix(PDEElement element, const PDMatrix* matrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEElementHitTest(PDEElement element, const PDPointF* point, bool* pResult);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDOCContextIsElementVisible(PDOCContext ctx, PDEElement element, bool* pVisible);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Container
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateContainer(PDAtom tag, PDObject dict, PDEElement* pContainer);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContainerGetTag(PDEElement container, PDAtom* pTag);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContainerSetTag(PDEElement container, PDAtom tag);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContainerGetDict(PDEElement container, PDObject* pDict);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContainerSetDict(PDEElement container, PDObject dict);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContainerGetContent(PDEElement container, PDEContent* pContent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEContainerGetOCMD(PDEElement container, PDOCMD* pOCMD);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Place
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreatePlace(PDAtom tag, PDObject dict, PDEElement* pPlace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPlaceGetTag(PDEElement place, PDAtom* pTag);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPlaceSetTag(PDEElement place, PDAtom tag);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPlaceGetDict(PDEElement place, PDObject* pDict);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPlaceSetDict(PDEElement place, PDObject dict);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Function
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGetFunctionFromPDObject(PDObject funcObj, PDEFunction* pFunc);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFunctionGetPDObject(PDEFunction func, PDObject* pObj);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFunctionGetNumInputs(PDEFunction func, size_t* pNumInputs);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFunctionGetNumOutputs(PDEFunction func, size_t* pNumOutputs);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFunctionExec(PDEFunction func, const float* inputs, float* outputs);
//----------------------------------------------------------
 
//----------------------------------------------------------
// SoftMask
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateSoftMask(PDDoc pddoc, PDESoftMask* pSMask);
PDF_CORE_API bool PDFSDK_CALLCONV PDESoftMaskEqual(PDESoftMask softMaskA, PDESoftMask softMaskB);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskGetSubtype(PDESoftMask softMask, PDESoftMaskSubtype* pSubtype);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskSetSubtype(PDESoftMask softMask, PDESoftMaskSubtype subtype);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskGetGroup(PDESoftMask softMask, PDEXObject* pGroup);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskSetGroup(PDESoftMask softMask, PDEXObject group);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskGetBackdropColor(PDESoftMask softMask, PDColorValue* pBackdrop);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskSetBackdropColor(PDESoftMask softMask, PDColorValue backdrop);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskGetTransfer(PDESoftMask softMask, PDEFunction* pTransfer);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskSetTransfer(PDESoftMask softMask, PDEFunction transfer);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Graphic state
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateGState(PDEGState* pGState);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateCopy(PDEGState gstate, PDEGState* pCopy);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillColor(PDEGState gstate, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillColorSpace(PDEGState gstate, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillColorNumComponents(PDEGState gstate, size_t* pNumComponents);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillColorComponents(PDEGState gstate, float* components);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillColorPattern(PDEGState gstate, PDEPattern* pPattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetFillColor(PDEGState gstate, PDEColor color);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetFillColorSpace(PDEGState gstate, PDEColorSpace colorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetFillColorComponents(PDEGState gstate, const float* components, size_t numComponents, PDEPattern pattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeColor(PDEGState gstate, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeColorSpace(PDEGState gstate, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeColorNumComponents(PDEGState gstate, size_t* pNumComponents);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeColorComponents(PDEGState gstate, float* components);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeColorPattern(PDEGState gstate, PDEPattern* pPattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeColor(PDEGState gstate, PDEColor color);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeColorSpace(PDEGState gstate, PDEColorSpace colorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeColorComponents(PDEGState gstate, const float* components, size_t numComponents, PDEPattern pattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetLineWidth(PDEGState gstate, float* pLineWidth);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetLineWidth(PDEGState gstate, float lineWidth);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetLineCap(PDEGState gstate, PDELineCap* pLineCap);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetLineCap(PDEGState gstate, PDELineCap lineCap);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetLineJoin(PDEGState gstate, PDELineJoin* pLineJoin);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetLineJoin(PDEGState gstate, PDELineJoin lineJoin);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetMiterLimit(PDEGState gstate, float* pMiterLimit);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetMiterLimit(PDEGState gstate, float miterLimit);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetDash(PDEGState gstate, PDEDash* pDash);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetDash(PDEGState gstate, const PDEDash* dash);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetIntent(PDEGState gstate, PDERenderingIntent* pIntent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetIntent(PDEGState gstate, PDERenderingIntent intent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeAdjustment(PDEGState gstate, bool* pAdjustStrokes);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeAdjustment(PDEGState gstate, bool adjustStrokes);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetBlendMode(PDEGState gstate, PDEBlendMode* pBlendMode);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetBlendMode(PDEGState gstate, PDEBlendMode blendMode);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetSoftMask(PDEGState gstate, PDESoftMask* pSoftMask);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetSoftMask(PDEGState gstate, PDESoftMask softMask);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetSoftMaskMatrix(PDEGState gstate, PDMatrix* pSoftMaskMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetSoftMaskMatrix(PDEGState gstate, const PDMatrix* softMaskMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillAlpha(PDEGState gstate, float* pAlpha);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetFillAlpha(PDEGState gstate, float alpha);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeAlpha(PDEGState gstate, float* pAlpha);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeAlpha(PDEGState gstate, float alpha);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetAlphaIsShape(PDEGState gstate, bool* pAlphaIsShape);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetAlphaIsShape(PDEGState gstate, bool alphaIsShape);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFillOverprint(PDEGState gstate, bool* pOverprint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetFillOverprint(PDEGState gstate, bool overprint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeOverprint(PDEGState gstate, bool* pOverprint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeOverprint(PDEGState gstate, bool overprint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetOverprintMode(PDEGState gstate, int* pOpm);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetOverprintMode(PDEGState gstate, int opm);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFlatness(PDEGState gstate, float* pFlatness);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetFlatness(PDEGState gstate, float flatness);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetSmoothness(PDEGState gstate, float* pSmoothness);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetSmoothness(PDEGState gstate, float smoothness);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetFlags(PDEGState gstate, PDEGStateFlags* pFlags);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Clip
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateClip(PDEClip* pClip);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEClipCopy(PDEClip clip, PDEClip* pCopy);
PDF_CORE_API bool PDFSDK_CALLCONV PDEClipEqual(PDEClip clipA, PDEClip clipB);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEClipGetBBox(PDEClip clip, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEClipGetNumElements(PDEClip clip, size_t* pNumElements);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEClipGetElement(PDEClip clip, size_t index, PDEElement* pElement);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEClipInsertElement(PDEClip clip, size_t index, PDEElement element);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEClipRemoveElement(PDEClip clip, size_t index);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Path
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreatePath(PDEElement* pPath);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathGetPaintOp(PDEElement path, PDEPaintOp* pPaintOp);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathSetPaintOp(PDEElement path, PDEPaintOp paintOp);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathEnum(PDEElement path, PDEPathEnumMonitor* mon, void* monClientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathGetNumSegments(PDEElement path, size_t* pNumSegments);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathGetSegment(PDEElement path, size_t index, PDEPathSegment* pSegment);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathAddSegment(PDEElement path, PDEPathSegment seg);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPathRemoveSegment(PDEElement path, size_t index);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Text
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateText(PDEElement* pText);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextGetNumItems(PDEElement text, size_t* pNumItems);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextGetItem(PDEElement text, size_t index, PDETextItem* pItem);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextGetItemAtPoint(PDEElement text, const PDPointF* pagePt, PDETextItem* pItem);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextInsertItem(PDEElement text, size_t index, PDETextItem item);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextRemoveItem(PDEElement text, size_t index);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextSplitItem(PDEElement text, size_t itemIndex, size_t charIndex);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextGetKnockout(PDEElement text, bool* pKnockout);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextSetKnockout(PDEElement text, bool knockout);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateTextItem(PDETextItem* pItem);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateTextItemEmptyCopy(PDETextItem item, PDETextItem* pItem);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemCopy(PDETextItem item, PDETextItem* pCopy);
PDF_CORE_API int PDFSDK_CALLCONV PDETextItemCompare(PDETextItem itemA, PDETextItem itemB);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemCopyChars(PDETextItem item, char* buffer, size_t bufferSize, size_t* pSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemCopyCharsByIndex(PDETextItem item, size_t index, char* buffer, size_t bufferSize, size_t* pSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetChars(PDETextItem item, const char* chars, size_t numChars);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemInsertChars(PDETextItem item, size_t index, const char* chars, size_t numChars);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemInsertUnicodeChars(PDETextItem item, size_t index, const UnicodeChar* unicodeID, size_t unicodeIDsize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemRemoveChars(PDETextItem item, size_t index, size_t numChars);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetGState(PDETextItem item, PDEGState* pState);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetGState(PDETextItem item, PDEGState gstate);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetTextState(PDETextItem item, PDETextState* pTextState);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetTextState(PDETextItem item, const PDETextState* textState);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetFont(PDETextItem item, PDEFont* pFont);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetFont(PDETextItem item, PDEFont font);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetFontSize(PDETextItem item, float* pFontSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetFontSize(PDETextItem item, float fontSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetTextMatrix(PDETextItem item, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetTextMatrix(PDETextItem item, const PDMatrix* matrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetNumChars(PDETextItem item, size_t* pNumChars);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetCharOutline(PDETextItem item, size_t index, const PDEOutlineEnumMonitor* mon, void* monClientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetType3CharProc(PDETextItem item, size_t index, PDEContent* pCharProc);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetCharAdvance(PDETextItem item, size_t index, PDPointF* pAdvance);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetCharVertMetric(PDETextItem item, size_t index, PDEGlyphVertMetric* pVertMetric);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetCharsRect(PDETextItem item, size_t begindex, size_t endindex, PDRectF* pRect);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetCharQuad(PDETextItem item, size_t index, PDQuad* pQuad);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetOutlineQuad(PDETextItem item, size_t index, PDQuad* pQuad);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetUnicodeText(PDETextItem item, UnicodeChar* buffer, size_t size, size_t* pSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetUnicodeChar(PDETextItem item, size_t index, UnicodeChar* buffer, size_t size, size_t* pSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetChar(PDETextItem item, size_t index, char* buffer, size_t size, size_t* pSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetGlyphIndex(PDETextItem item, size_t index, unsigned int* pGlyphIndex);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetBBox(PDETextItem item, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetMatrix(PDETextItem item, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSetMatrix(PDETextItem item, const PDMatrix* matrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetParent(PDETextItem item, PDEElement* pText);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemSplitInplace(PDETextItem item, size_t charIndex, PDETextItem* pItem);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemIsCharWhitespace(PDETextItem item, size_t charIndex, bool* pIsWhitespace);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextLayout(PDDoc doc,
                                                     const wchar_t* text,
                                                     const PDRectF* rect,
                                                     const PDFontInfo* font,
                                                     float fontSize,
                                                     PDColorValue fontColor,
                                                     PDETextAlign alignment,
                                                     PDEElement* pText);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Inline image
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateInlineImage(PDEImageAttrs* attrs, PDEColorSpace cs, const char* data, PDEElement* pElement);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateInlineImageCrop(PDEElement image, const PDRectI* cropRect, PDEElement* pOut);
PDF_CORE_API int PDFSDK_CALLCONV PDEInlineImageCompare(PDEElement imageA, PDEElement imageB);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageGetAttrs(PDEElement image, PDEImageAttrs* pAttrs);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageGetColorSpace(PDEElement image, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageGetInterpolate(PDEElement image, bool* pInterpolate);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageSetInterpolate(PDEElement image, bool interpolate);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageGetIntent(PDEElement image, PDERenderingIntent* pIntent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageSetIntent(PDEElement image, PDERenderingIntent intent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageGetDecodeArray(PDEElement image, float* decodeArray, size_t decodeArraySize, size_t* pDecodeArraySize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEInlineImageOpenStream(PDEElement image, PDReadStream* pStream);
//----------------------------------------------------------
 
//----------------------------------------------------------
// XObject element
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateXObjectElement(PDEXObject xobject, PDEElement* pElement);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateXObjectElementCrop(PDEElement xoe, const PDRectI* cropRect, PDEElement* pCrop);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXObjectElementGetXObject(PDEElement xoe, PDEXObject* pXObject);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXObjectElementSetXObject(PDEElement xoe, PDEXObject xobject);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Shading element
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateShadingElement(PDEShading shading, PDEElement* pElement);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingElementGetShading(PDEElement she, PDEShading* pShading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingElementSetShading(PDEElement she, PDEShading shading);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Color space
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGetColorSpaceFromPDObject(PDObject csObj, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorSpaceDeviceGray(PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorSpaceDeviceRGB(PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorSpaceDeviceCMYK(PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorSpacePattern(PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorSpaceICCBasedFromFile(PDDoc doc, const wchar_t* profilePath, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorSpaceICCBasedFromBuffer(PDDoc doc, const void* buffer, size_t size, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceGetPDObject(PDEColorSpace colorSpace, PDObject* pObj);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceGetFamily(PDEColorSpace colorSpace, PDEColorSpaceFamily* pFamily);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceGetNumComponents(PDEColorSpace colorSpace, size_t* pNumComponents);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceGetComponentRange(PDEColorSpace colorSpace, size_t index, PDENumRange* pRange);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceDoesProduceOutput(PDEColorSpace colorSpace, bool* pResult);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceIsSpecial(PDEColorSpace colorSpace, bool* pResult);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpacePackColor(PDEColorSpace colorSpace, const float* components, void* buffer);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceUnpackColor(PDEColorSpace colorSpace, const void* buffer, float* components);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceTransformToRGB(PDEColorSpace colorSpace, const float* components, PDERenderingIntent intent, PDColorValue* pRGB);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceTransformImageDataToRGB(PDEColorSpace colorSpace, const void* data, int numEntries, PDERenderingIntent intent, void* buffer);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorSpaceTransformImageData(PDEColorSpace srcColorSpace, PDEColorSpace dstColorSpace, const void* data, int numEntries, PDERenderingIntent intent, void* buffer);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Color
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColor(PDEColorSpace colorSpace, float const* components, size_t numComponents, PDEPattern pattern, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorGray(float gray, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorRGB(float red, float green, float blue, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateColorFromValue(PDColorValue value, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorGetColorSpace(PDEColor color, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorGetNumComponents(PDEColor colorSpace, size_t* pNumComponents);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorGetComponent(PDEColor color, size_t index, float* pComponent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorGetComponents(PDEColor color, float* components);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorGetPattern(PDEColor color, PDEPattern* pPattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEColorToRGB(PDEColor color, PDERenderingIntent intent, PDColorValue* pRGB);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Pattern
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGetPatternFromPDObject(PDObject patternObj, PDEPattern* pPattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternGetPDObject(PDEPattern pattern, PDObject* pObj);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternGetType(PDEPattern pattern, PDEPatternType* pType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternGetMatrix(PDEPattern pattern, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternSetMatrix(PDEPattern pattern, const PDMatrix* matrix);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreatePatternTiling(PDDoc doc,
                                                              PDETilingPatternPaintType paintType,
                                                              PDETilingPatternTilingType tilingType,
                                                              const PDRectF* bbox,
                                                              float xstep,
                                                              float ystep,
                                                              PDEContent content,
                                                              PDEPattern* pPattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingGetPaintType(PDEPattern pattern, PDETilingPatternPaintType* pPaintType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingSetPaintType(PDEPattern pattern, PDETilingPatternPaintType paintType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingGetTilingType(PDEPattern pattern, PDETilingPatternTilingType* pTilingType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingSetTilingType(PDEPattern pattern, PDETilingPatternTilingType tilingType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingGetBBox(PDEPattern pattern, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingSetBBox(PDEPattern pattern, const PDRectF* bbox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingGetXStep(PDEPattern pattern, float* pXStep);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingSetXStep(PDEPattern pattern, float xstep);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingGetYStep(PDEPattern pattern, float* pYStep);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingSetYStep(PDEPattern pattern, float ystep);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternTilingGetContent(PDEPattern pattern, PDEContent* pContent);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreatePatternShading(PDDoc doc, PDEShading shading, PDEPattern* pPattern);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternShadingGetShading(PDEPattern pattern, PDEShading* pShading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternShadingSetShading(PDEPattern pattern, PDEShading shading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternShadingGetExtGState(PDEPattern pattern, PDEGState* pExtGState);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEPatternShadingSetExtGState(PDEPattern pattern, PDEGState extGState);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Shading
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGetShadingFromPDObject(PDObject shadingObj, PDEShading* pShading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingGetPDObject(PDEShading shading, PDObject* pObj);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingGetType(PDEShading shading, PDEShadingType* pType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingGetColorSpace(PDEShading shading, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingGetBackground(PDEShading shading, PDEColor* pBackground);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingSetBackground(PDEShading shading, PDEColor background);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingGetBBox(PDEShading shading, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingSetBBox(PDEShading shading, const PDRectF* bbox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingGetAntiAlias(PDEShading shading, bool* pAntiAlias);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingSetAntiAlias(PDEShading shading, bool antiAlias);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateShadingFunctionBased(PDDoc doc, PDEColorSpace colorSpace, PDEFunction function, PDEShading* pShading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedGetXDomain(PDEShading shading, PDENumRange* pDomain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedSetXDomain(PDEShading shading, PDENumRange const* domain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedGetYDomain(PDEShading shading, PDENumRange* pDomain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedSetYDomain(PDEShading shading, PDENumRange const* domain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedGetMatrix(PDEShading shading, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedSetMatrix(PDEShading shading, const PDMatrix* matrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedGetFunction(PDEShading shading, PDEFunction* pFunction);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFunctionBasedSetFunction(PDEShading shading, PDEFunction function);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateShadingAxial(PDDoc doc, PDEColorSpace colorSpace, PDEFunction function, const PDPointF* start, const PDPointF* end, PDEShading* pShading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialGetStartPoint(PDEShading shading, PDPointF* pPoint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialSetStartPoint(PDEShading shading, const PDPointF* point);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialGetEndPoint(PDEShading shading, PDPointF* pPoint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialSetEndPoint(PDEShading shading, const PDPointF* point);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialGetFunction(PDEShading shading, PDEFunction* pFunction);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialSetFunction(PDEShading shading, PDEFunction function);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialGetDomain(PDEShading shading, PDENumRange* pDomain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialSetDomain(PDEShading shading, PDENumRange const* domain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialGetExtendStart(PDEShading shading, bool* pExtend);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialSetExtendStart(PDEShading shading, bool extend);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialGetExtendEnd(PDEShading shading, bool* pExtend);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingAxialSetExtendEnd(PDEShading shading, bool extend);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateShadingRadial(PDDoc doc, PDEColorSpace colorSpace, PDEFunction function, const PDPointF* start, float startRadius, const PDPointF* end, float endRadius, PDEShading* pShading);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetStartPoint(PDEShading shading, PDPointF* pPoint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetStartPoint(PDEShading shading, const PDPointF* point);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetStartRadius(PDEShading shading, float* pRadius);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetStartRadius(PDEShading shading, float radius);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetEndPoint(PDEShading shading, PDPointF* pPoint);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetEndPoint(PDEShading shading, const PDPointF* point);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetEndRadius(PDEShading shading, float* pRadius);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetEndRadius(PDEShading shading, float radius);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetFunction(PDEShading shading, PDEFunction* pFunction);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetFunction(PDEShading shading, PDEFunction function);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetDomain(PDEShading shading, PDENumRange* pDomain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetDomain(PDEShading shading, PDENumRange const* domain);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetExtendStart(PDEShading shading, bool* pExtend);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetExtendStart(PDEShading shading, bool extend);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialGetExtendEnd(PDEShading shading, bool* pExtend);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingRadialSetExtendEnd(PDEShading shading, bool extend);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFreeFormGouraudGetFunction(PDEShading shading, PDEFunction* pFunction);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFreeFormGouraudSetFunction(PDEShading shading, PDEFunction function);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFreeFormGouraudGetNumVertices(PDEShading shading, size_t* pNumVertices);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFreeFormGouraudGetVertexCoord(PDEShading shading, size_t index, PDPointF* pCoord);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingFreeFormGouraudGetVertexColor(PDEShading shading, size_t index, PDERenderingIntent intent, PDColorValue* pColor);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingLatticeFormGouraudGetFunction(PDEShading shading, PDEFunction* pFunction);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingLatticeFormGouraudSetFunction(PDEShading shading, PDEFunction function);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingLatticeFormGouraudGetNumVertices(PDEShading shading, size_t* pNumVertices);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingLatticeFormGouraudGetVerticesPerRow(PDEShading shading, size_t* pVerticesPerRow);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingLatticeFormGouraudGetVertexCoord(PDEShading shading, size_t index, PDPointF* pCoord);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingLatticeFormGouraudGetVertexColor(PDEShading shading, size_t index, PDERenderingIntent intent, PDColorValue* pColor);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingPatchMeshGetFunction(PDEShading shading, PDEFunction* pFunction);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingPatchMeshSetFunction(PDEShading shading, PDEFunction function);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingPatchMeshGetNumPatches(PDEShading shading, size_t* pNumPatches);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingPatchMeshGetPatchCoords(PDEShading shading, size_t index, PDPointF pCoords[16]);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEShadingPatchMeshGetPatchColors(PDEShading shading, size_t index, PDERenderingIntent intent, PDColorValue pColors[4]);
//----------------------------------------------------------
 
//----------------------------------------------------------
// XObject
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGetXObjectFromPDObject(PDObject obj, PDEXObject* pXObject);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocImportIcon(PDDoc doc, PDDoc to, size_t pageNo, PDEXObject* xobject);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocCreatePageFromIcon(PDDoc doc, size_t insertAt, PDDoc iconDoc, PDEXObject icon);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateFormXObject(PDDoc doc, PDEContent content, PDEXObject* pXObject);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectCopy(PDEXObject source, PDEXObject* pXObject);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectGetBBox(PDEXObject xform, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectSetBBox(PDEXObject xform, const PDRectF* bbox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectGetMatrix(PDEXObject xform, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectSetMatrix(PDEXObject xform, const PDMatrix* matrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectGetContent(PDEXObject xform, PDEContent* pContent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectSetContent(PDEXObject xform, const PDEContent content);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectGetXGroup(PDEXObject xform, PDEXGroup* pGroup);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectSetXGroup(PDEXObject xform, PDEXGroup group);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectGetOCMD(PDEXObject xform, PDOCMD* pOCMD);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectSetOCMD(PDEXObject xform, PDOCMD ocmd);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFormXObjectSetADBECompoundType(PDEXObject xform, const char* type);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateXGroup(PDEColorSpace colorSpace, PDEXGroupFlags flags, PDEXGroup* pGroup);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXGroupGetColorSpace(PDEXGroup group, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXGroupSetColorSpace(PDEXGroup group, PDEColorSpace colorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXGroupGetFlags(PDEXGroup group, PDEXGroupFlags* pFlags);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXGroupSetFlags(PDEXGroup group, PDEXGroupFlags flags);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateImageXObject(PDDoc doc, PDEImageAttrs const* attrs, PDEColorSpace cs, const void* imageData, PDAtom compressionFilter, PDEXObject* pXObject);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateImageXObjectEmbedJpeg(PDDoc doc, const wchar_t* jpegImagePath, PDEXObject* pXObject);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateImageXObjectCrop(PDEXObject ximage, const PDRectI* cropRect, PDEXObject* pOut);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXObjectGetType(PDEXObject xobj, PDEXObjectType* pType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXObjectGetPDObject(PDEXObject xobj, PDObject* pObj);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEXObjectConvertColorSpace(PDDoc doc, PDEXObject xobj, PDEColorSpace targetCS, PDEXObject* pOut);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetAttrs(PDEXObject ximage, PDEImageAttrs* pAttrs);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetColorSpace(PDEXObject ximage, PDEColorSpace* pColorSpace);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectHasAlphaChannelInData(PDEXObject ximage, bool* pHasAlphaChannel);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetInterpolate(PDEXObject ximage, bool* pInterpolate);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectSetInterpolate(PDEXObject ximage, bool interpolate);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetIntent(PDEXObject ximage, PDERenderingIntent* pIntent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectSetIntent(PDEXObject ximage, PDERenderingIntent intent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectResetIntent(PDEXObject ximage);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetDecodeArray(PDEXObject ximage, float* decodeArray, size_t decodeArraySize, size_t* pOutDecodeArraySize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetMask(PDEXObject ximage, PDEXObject* pMask);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectSetMask(PDEXObject ximage, PDEXObject mask);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetColorKey(PDEXObject ximage, int* colorKey);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetSMask(PDEXObject ximage, PDEXObject* pSMask);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectSetSMask(PDEXObject ximage, PDEXObject smask);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetSMaskInData(PDEXObject ximage, int* pSMaskInData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetMatteArray(PDEXObject ximage, float* matteArray);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectSetMatteArray(PDEXObject ximage, const float* matteArray);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectGetOCMD(PDEXObject ximage, PDOCMD* pOCMD);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectSetOCMD(PDEXObject ximage, PDOCMD ocmd);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageGetCompressionFilter(PDEXObject ximage, PDAtom* pComppressionFilter);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEImageXObjectOpenStream(PDEXObject ximage, PDReadStream* pStream);
//----------------------------------------------------------
 
//----------------------------------------------------------
// Font
//----------------------------------------------------------
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGetFontFromPDObject(PDObject fontObj, PDEFont* pFont);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateFontFromInfo(PDDoc doc, const PDFontInfo* fontInfo, bool forceSysFont, PDEFontCreateFlags createFlags, PDEFont* pFont);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateFontToTypeUnicode(PDDoc doc, PDEFont font, const UnicodeChar* unicode, size_t unicodeLen, PDEFontFauxType* pFauxType, PDEFontCreateFlags createFlags, PDEFont* pFont);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetPDObject(PDEFont font, PDObject* pFontObj);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetSubtype(PDEFont font, PDEFontSubtype* pSubtype);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetName(PDEFont font, PDAtom* pName);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetMetrics(PDEFont font, PDEFontMetrics* pMetrics);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetFontMatrix(PDEFont font, PDMatrix* pMatrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetFontBBox(PDEFont font, PDRectF* pBBox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetWritingMode(PDEFont font, PDEWritingMode* pWMode);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetStyle(PDEFont font, PDFontStyle* style);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetFontInfo(PDEFont font, PDFontInfo* pInfo);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetCIDSystemInfo(PDEFont font, PDECIDSystemInfo* pInfo);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetEncodingName(PDEFont font, PDAtom* pEncodingName);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontIsFauxed(PDEFont font, bool* pFauxed);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetFauxFontInfo(PDEFont font, PDFontInfo* pInfo);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontFindSubstFontInfo(PDEFont font, bool forceBold, bool forceItalic, PDFontInfo* pInfo);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEAddFontNameSubstitution(PDAtom pdfFontName,
                                                                  PDAtom substFamilyName,
                                                                  PDFontStyle substStyle,
                                                                  uint32_t* pHandlerID);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDERemoveFontNameSubstitution(uint32_t handlerID);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEAddCIDFontSubstitution(const PDECIDSystemInfo* cidSystemInfo,
                                                                 PDAtom substFamilyName,
                                                                 PDFontStyle substStyle,
                                                                 uint32_t* pHandlerID);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDERemoveCIDFontSubstitution(uint32_t handlerID);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetSubstMetrics(PDEFont font, PDEFontMetrics* pMetrics);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetType3GlyphsBBox(PDEFont font, PDRectF* pBBox);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontIsEmbedded(PDEFont font, bool* pEmbedded);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetFontFileFormat(PDEFont font, PDEFontFileFormat* pFormat);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontOpenFontFileStream(PDEFont font, PDReadStream* pStream);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetFontFileData(PDEFont font, void* buffer, size_t bufsize, size_t* pSize);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateFontEmbeddedCopy(PDDoc doc, const PDEFont sourceFont, PDEFontCreateFlags createFlags, PDEFont* pFontEmbeddedCopy);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEConvertFontToType0(PDDoc doc, const PDEFont sourceFont, PDEFontCreateFlags createFlags, PDEFont* pFontType0);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontHasValidCIDSet(PDEFont font, bool* pHasValidCIDSet);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCreateCIDSet(PDEFont font, PDDoc doc);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontHasRenderableGlyphs(PDEFont font, bool* pHasRenderableGlyphs);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontHasValidCharSet(PDEFont font, bool* pHasValidCharSet);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCreateCharSet(PDEFont font, PDDoc doc);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontSetType3FontBBox(PDEFont font, const PDRectF* bbox);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontSetType3FontMatrix(PDEFont font, const PDMatrix* matrix);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetType3CharProc(PDEFont font, uint8_t charcode, PDEContent* pContent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetType3GlyphInfo(PDEFont font, uint8_t charcode, PDEType3GlyphInfo* pGlyphInfo);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontSetType3CharProc(PDEFont font, uint8_t charcode, const PDEType3GlyphInfo* glyphInfo, PDEContent content);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontEnumCharOutline(PDEFont font, const char* codepoint, size_t codepointLen, const PDEOutlineEnumMonitor* mon, void* monClientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetCharWidth(PDEFont font, const char* codepoint, size_t codepointLen, int16_t* pWidth);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontIsGlyphPresent(PDEFont font, const char* codepoint, size_t codepointLen, bool* pIsPresent);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetCharVertMetric(PDEFont font, const char* codepoint, size_t codepointLen, PDEGlyphVertMetric* pVertMetric);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontHasValidToUnicodeMap(PDEFont font, PDEFontToUnicodeCheckFlags checkFlags, bool* pHasValidToUnicodeMap);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCreateToUnicodeMap(PDEFont font, PDDoc doc, PDEFontToUnicodeCreateFlags createFlags);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCanTypeUnicode(PDEFont font, const UnicodeChar* unicode, size_t unicodeLen, bool* pCanType);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCharToUnicode(PDEFont font, char const* codepoint, size_t codepointLen, bool noFallback, UnicodeChar* unicode, size_t unicodeLen, size_t* pUnicodeLen);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCharToUnicodeEx(PDEFont font, char const* codepoint, size_t codepointLen, bool noFallback, UnicodeChar* unicode, size_t unicodeLen, size_t* pUnicodeLen);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontUnicodeToChar(PDEFont font, UnicodeChar const* unicode, size_t unicodeLen, char* codepoint, size_t codepointLen, size_t* pCodepointLen);
 
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontHasValidWidths(PDEFont font, bool* pHasValidWidths);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCreateWidths(PDEFont font, PDDoc doc);
 
typedef PDErrCode(PDFSDK_CALLCONV* PDFontResourceEnumProc)(PDEFont font, void* clientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDDocEnumFonts(PDDoc doc, PDFontResourceEnumProc proc, void* clientData, const PDProgressMonitor* mon, void* monData);
//----------------------------------------------------------
 
#ifdef __cplusplus
}
#endif
 
#endif  // PDFSDK_CORE_CONTENT_H_INCLUDED_