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 {
    kPDEGStateHasFillColor = 0x1,
    kPDEGStateHasStrokeColor = 0x2,
    kPDEGStateHasLineWidth = 0x4,
    kPDEGStateHasMiterLimit = 0x8,
    kPDEGStateHasLineCap = 0x10,
    kPDEGStateHasLineJoin = 0x20,
    kPDEGStateHasDash = 0x40,
    kPDEGStateHasIntent = 0x80,
    kPDEGStateHasStrokeAdjustment = 0x100,
    kPDEGStateHasBlendMode = 0x200,
    kPDEGStateHasSoftMask = 0x400,
    kPDEGStateHasFillAlpha = 0x800,
    kPDEGStateHasStrokeAlpha = 0x1000,
    kPDEGStateHasAlphaIsShape = 0x2000,
    kPDEGStateHasFillOverprint = 0x4000,
    kPDEGStateHasStrokeOverprint = 0x8000,
    kPDEGStateHasOverprintMode = 0x10000,
    kPDEGStateHasFlatness = 0x20000,
    kPDEGStateHasSmoothness = 0x40000
};
typedef uint32_t PDEGStateFlags;
//----------------------------------------------------------
 
typedef struct PDEContentRec_* PDEContent;
 
//----------------------------------------------------------
// Content element
typedef struct PDEElementRec_* PDEElement;
 
typedef enum {
    kPDEElementUnknown,
    /*
    A group of PDEElement objects on a page in a PDF file.In the PDF file, containers are
    delimited by Marked Content BMC / EMC or BDC / EMC pairs.Every PDEContainer
    has a Marked Content tag associated with it.In addition to grouping a set of elements,
    a BDC / EMC pair specifies a property list to be associated with the grouping.Thus, a
    PDEContainer corresponding to a BDC / EMC pair also has a property list dictionary
    associated with it.
    */
    kPDEElementContainer,
    kPDEElementPlace,
    /*
    A path object is an arbitrary shape made up of straight lines, rectangles, and cubic Bézier
    curves. A path may intersect itself and may have disconnected sections and holes.
    A path object ends with one or more painting operators that specify whether the path shall be stroked,
    filled, used as a clipping boundary, or some combination of these operations.
    */
    kPDEElementPath,
    /*
    A text object consists of one or more character strings that identify sequences of glyphs to be painted.
    Like a path, text can be stroked, filled, or used as a clipping boundary.
    */
    kPDEElementText,
    /*
    An inline image object uses a special syntax to express the data for a small image directly within the content stream.
    */
    kPDEElementInlineImage,
    /*
    An external object (XObject) is an object defined outside the content stream and referenced as a named resource.
    */
    kPDEElementXObject,
    /*
    A shading object describes a geometric shape whose colour is an arbitrary function of position within the shape.
    */
    kPDEElementShading
} PDEElementType;
//----------------------------------------------------------
 
//----------------------------------------------------------
// 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 uint8_t 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;
 
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 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,
} PDEFontFauxType;
 
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 struct {
    const PDEFontMetrics* metrics;
    int firstChar;
    int lastChar;
    const int16_t* widths;
    const char** encoding;
    PDAtom baseEncoding;
} PDECreateFontParams;
 
typedef enum {
    kPDETextAlignLeft,
    kPDETextAlignCenter,
    kPDETextAlignRight,
    kPDETextAlignJustify,
    kPDETextAlignBoth,  // Same as above, but also justify the last line
} 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 PDOCConfigIsElementVisible(PDOCConfig config, 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 PDEElement PDFSDK_CALLCONV PDECreatePlace(PDAtom tag, PDObject dict);
// 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, PDEColor* pBackdrop);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDESoftMaskSetBackdropColor(PDESoftMask softMask, PDEColor 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 PDEGStateSetFillColor(PDEGState gstate, PDEColor color);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateGetStrokeColor(PDEGState gstate, PDEColor* pColor);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEGStateSetStrokeColor(PDEGState gstate, PDEColor color);
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, UnicodeChar const* 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, PDEOutlineEnumMonitor* mon, void* monClientData);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDETextItemGetCharProc(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 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 PDETextItemSetParent(PDETextItem item, PDEElement pText); //TODO:remove it
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);
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);
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 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 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);
//----------------------------------------------------------
 
//----------------------------------------------------------
// 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 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 PDECreateFontInDoc(PDDoc doc, const PDFontInfo* fontInfo, bool needSubset, bool forceSysFont, PDEFont* pFont);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDECreateFontToTypeUnicode(PDDoc doc, PDEFont font, const UnicodeChar* unicode, size_t unicodeLen, PDEFontFauxType* pFauxType, 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 PDEFontIsEmbedded(PDEFont font, bool* pEmbedded);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetWritingMode(PDEFont font, PDEWritingMode* pWMode);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetCharProc(PDEFont font, const char* codepoint, size_t codepointLen, PDEContent* pCharProc);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontEnumCharOutline(PDEFont font, const char* codepoint, size_t codepointLen, 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 PDEFontGetCharVertMetric(PDEFont font, const char* codepoint, size_t codepointLen, PDEGlyphVertMetric* pVertMetric);
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 PDEFontGetEncodingName(PDEFont font, PDAtom* pEncodingName);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCanTypeUnicode(PDEFont font, const UnicodeChar* unicode, size_t unicodeLen, bool* pCanType);
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 PDEFontOpenFontFileStream(PDEFont font, PDReadStream* pStream);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontCharToUnicode(PDEFont font, char const* codepoint, size_t codepointLen, 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 PDEFontFindSubstFontInfo(PDEFont font, bool forceBold, bool forceItalic, PDFontInfo* pInfo);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetSubstMetrics(PDEFont font, PDEFontMetrics* pMetrics);
PDF_CORE_API PDErrCode PDFSDK_CALLCONV PDEFontGetType3GlyphsBBox(PDEFont font, PDRectF* pBBox);
//----------------------------------------------------------
 
#ifdef __cplusplus
}
#endif
 
#endif  // PDFSDK_CORE_CONTENT_H_INCLUDED_