fs_base_r.h

Go to the documentation of this file.

#ifndef _FSCRT_BASE_R_H_
#define _FSCRT_BASE_R_H_

#ifdef __cplusplus
extern "C" {
#endif

/*******************************************************************************/
/* Base types                                                                  */
/*                                                                             */
/* Basic types, handle definitions, error codes and variants                   */
/*******************************************************************************/
#ifndef _FSCRT_DEF_TYPE_BASETYPES_
#define _FSCRT_DEF_TYPE_BASETYPES_

typedef void*                                   FS_LPVOID;

typedef void const*                             FS_LPCVOID;

typedef int                                             FS_BOOL;

typedef unsigned char                   FS_BYTE;

typedef unsigned short                  FS_WORD;

typedef unsigned int                    FS_DWORD;

typedef unsigned int                    FS_ARGB;

typedef float                                   FS_FLOAT;

typedef char                                    FS_CHAR;

typedef char*                                   FS_LPSTR;

typedef char const*                             FS_LPCSTR;

typedef int                                             FS_RESULT;

typedef char                                    FS_INT8;

typedef unsigned char                   FS_UINT8;

typedef short                                   FS_INT16;

typedef unsigned short                  FS_UINT16;

typedef int                                             FS_INT32;

typedef unsigned int                    FS_UINT32;

#endif /* _FSCRT_DEF_TYPE_BASETYPES_ */

#ifndef _FSCRT_DEF_HANDLE_DEFINE_
#define _FSCRT_DEF_HANDLE_DEFINE_

/* Macro to define variant handle type. */
#define FSCRT_DEFINEHANDLE(name)        typedef struct _##name {FS_LPVOID pData;} * name;

#endif /* _FSCRT_DEF_HANDLE_DEFINE_ */

#ifndef _FSCRT_DEF_MACRO_ERRCODE_
#define _FSCRT_DEF_MACRO_ERRCODE_

#define FSCRT_ERRCODE_SUCCESS                                   0

#define FSCRT_ERRCODE_ERROR                                             -1

#define FSCRT_ERRCODE_INVALIDMANAGER                    -2

#define FSCRT_ERRCODE_INVALIDMODULE                             -3

#define FSCRT_ERRCODE_UNRECOVERABLE                             -4

#define FSCRT_ERRCODE_OUTOFMEMORY                               -5

#define FSCRT_ERRCODE_PASSWORD                                  -6

#define FSCRT_ERRCODE_FORMAT                                    -7

#define FSCRT_ERRCODE_FILE                                              -8

#define FSCRT_ERRCODE_PARAM                                             -9

#define FSCRT_ERRCODE_INVALIDLICENSE                    -10

#define FSCRT_ERRCODE_HANDLER                                   -11

#define FSCRT_ERRCODE_UNKNOWNSECURITYHANDLER    -12

#define FSCRT_ERRCODE_INVALIDCERTIFICATE                -13

#define FSCRT_ERRCODE_NOTFOUND                                  -14

#define FSCRT_ERRCODE_INVALIDTYPE                               -15

#define FSCRT_ERRCODE_UNSUPPORTED                               -16

#define FSCRT_ERRCODE_NOTPARSED                                 -17

#define FSCRT_ERRCODE_UNKNOWNSTATE                              -18

#define FSCRT_ERRCODE_BUFFEROVERFLOW                    -19

#define FSCRT_ERRCODE_CONFLICT                                  -20

#define FSCRT_ERRCODE_DATANOTREADY                              -21

#define FSCRT_ERRCODE_MEMORYREBUILT                             -22

#define FSCRT_ERRCODE_UNKNOWNHANDLER                    -23

#define FSCRT_ERRCODE_TOBECONTINUED                             1

#define FSCRT_ERRCODE_FINISHED                                  2

#define FSCRT_ERRCODE_ROLLBACK                                  3

#define FSCRT_SUCCEEDED(result)                                 ((FS_RESULT)(result) >= 0) 

#define FSCRT_FAILED(result)                                    ((FS_RESULT)(result) < 0)

#endif /* _FSCRT_DEF_MACRO_ERRCODE_ */

#ifndef _FSCRT_DEF_MACRO_VT_
#define _FSCRT_DEF_MACRO_VT_

#define FSCRT_VT_EMPTY                  0x00000000

#define FSCRT_VT_INT8                   0x00000001

#define FSCRT_VT_UINT8                  0x00000002

#define FSCRT_VT_INT16                  0x00000003

#define FSCRT_VT_UINT16                 0x00000004

#define FSCRT_VT_INT32                  0x00000005

#define FSCRT_VT_UINT32                 0x00000006

#define FSCRT_VT_BOOL                   0x00000007

#define FSCRT_VT_FLOAT                  0x00000008

#define FSCRT_VT_RECTF                  0x00000009

#define FSCRT_VT_LPVOID                 0x80000000

#define FSCRT_VT_LPINT8                 (FSCRT_VT_LPVOID | FSCRT_VT_INT8)

#define FSCRT_VT_LPUINT8                (FSCRT_VT_LPVOID | FSCRT_VT_UINT8)

#define FSCRT_VT_LPINT16                (FSCRT_VT_LPVOID | FSCRT_VT_INT16)

#define FSCRT_VT_LPUINT16               (FSCRT_VT_LPVOID | FSCRT_VT_UINT16)

#define FSCRT_VT_LPINT32                (FSCRT_VT_LPVOID | FSCRT_VT_INT32)

#define FSCRT_VT_LPUINT32               (FSCRT_VT_LPVOID | FSCRT_VT_UINT32)

#define FSCRT_VT_LPBOOL                 (FSCRT_VT_LPVOID | FSCRT_VT_BOOL)

#define FSCRT_VT_LPFLOAT                (FSCRT_VT_LPVOID | FSCRT_VT_FLOAT)

#define FSCRT_VT_CHAR                   FSCRT_VT_INT8

#define FSCRT_VT_BYTE                   FSCRT_VT_UINT8

#define FSCRT_VT_WORD                   FSCRT_VT_UINT16

#define FSCRT_VT_RESULT                 FSCRT_VT_INT32

#define FSCRT_VT_DWORD                  FSCRT_VT_UINT32

#define FSCRT_VT_ARGB                   FSCRT_VT_UINT32

#define FSCRT_VT_LPSTR                  FSCRT_VT_LPINT8

#define FSCRT_VT_LPCSTR                 FSCRT_VT_LPINT8

#define FSCRT_VT_LPBYTE                 FSCRT_VT_LPUINT8

#define FSCRT_VT_LPWORD                 FSCRT_VT_LPUINT16

#define FSCRT_VT_LPRESULT               FSCRT_VT_LPINT32

#define FSCRT_VT_LPDWORD                FSCRT_VT_LPUINT32

#define FSCRT_VT_LPARGB                 FSCRT_VT_LPUINT32

#define FSCRT_VT_BSTR                   (FSCRT_VT_LPVOID|0x00000010)

#define FSCRT_VT_OBJECT                 (FSCRT_VT_LPVOID|0x00001000)

#endif /* _FSCRT_DEF_MACRO_VT_ */

/*******************************************************************************/
/* Extend of Object Types                                                      */
/*                                                                             */
/*******************************************************************************/
#ifndef _FSPDF_DEF_MACRO_VT_OBJECT_
#define _FSPDF_DEF_MACRO_VT_OBJECT_

#define FSCRT_VT_OBJECT_LAYER           (FSCRT_VT_OBJECT|0x000000001)

#define FSCRT_VT_OBJECT_PAGEOBJECT      (FSCRT_VT_OBJECT|0x000000002)

#endif /* _FSPDF_DEF_MACRO_VT_OBJECT_ */

#ifndef _FSCRT_DEF_STRUCTURE_VAR_
#define _FSCRT_DEF_STRUCTURE_VAR_

typedef struct _FSCRT_VAR
{
        FS_DWORD        type;
        FS_DWORD        reserved;
        union
        {
                FS_INT8         int8Var;
                FS_UINT8        uint8Var;
                FS_INT16        int16Var;
                FS_UINT16       uint16Var;
                FS_INT32        int32Var;
                FS_UINT32       uint32Var;
                FS_BOOL         boolVar;
                FS_FLOAT        floatVar;
                FS_LPVOID       voidPtrVar;
                FS_INT8*        int8PtrVar;
                FS_UINT8*       uint8PtrVar;
                FS_INT16*       int16PtrVar;
                FS_UINT16*      uint16PtrVar;
                FS_INT32*       int32PtrVar;
                FS_UINT32*      uint32PtrVar;
                FS_BOOL*        boolPtrVar;
                FS_FLOAT*       floatPtrVar;
        } var;
} FSCRT_VAR;

#define FSCRT_Var_SetInt8Value(variant, value)                  (variant).type = FSCRT_VT_INT8, (variant).var.int8Var = (value);

#define FSCRT_Var_SetUInt8Value(variant, value)                 (variant).type = FSCRT_VT_UINT8, (variant).var.uint8Var = (value);

#define FSCRT_Var_SetInt16Value(variant, value)                 (variant).type = FSCRT_VT_INT16, (variant).var.int16Var = (value);

#define FSCRT_Var_SetUInt16Value(variant, value)                (variant).type = FSCRT_VT_UINT16, (variant).var.uint16Var = (value);

#define FSCRT_Var_SetInt32Value(variant, value)                 (variant).type = FSCRT_VT_INT32, (variant).var.int32Var = (value);

#define FSCRT_Var_SetUInt32Value(variant, value)                (variant).type = FSCRT_VT_UINT32, (variant).var.uint32Var = (value);

#define FSCRT_Var_SetBooleanValue(variant, value)               (variant).type = FSCRT_VT_BOOL, (variant).var.boolVar = (value);

#define FSCRT_Var_SetFloatValue(variant, value)                 (variant).type = FSCRT_VT_FLOAT, (variant).var.floatVar = (value);

#define FSCRT_Var_SetVoidPtrValue(variant, value)               (variant).type = FSCRT_VT_LPVOID, (variant).var.voidPtrVar = (value);

#define FSCRT_Var_SetInt8PtrValue(variant, value)               (variant).type = FSCRT_VT_LPINT8, (variant).var.int8PtrVar = (value);

#define FSCRT_Var_SetUInt8PtrValue(variant, value)              (variant).type = FSCRT_VT_LPUINT8, (variant).var.uint8PtrVar = (value);

#define FSCRT_Var_SetInt16PtrValue(variant, value)              (variant).type = FSCRT_VT_LPINT16, (variant).var.int16PtrVar = (value);

#define FSCRT_Var_SetUInt16PtrValue(variant, value)             (variant).type = FSCRT_VT_LPUINT16, (variant).var.uint16PtrVar = (value);

#define FSCRT_Var_SetInt32PtrValue(variant, value)              (variant).type = FSCRT_VT_LPINT32, (variant).var.int32PtrVar = (value);

#define FSCRT_Var_SetUInt32PtrValue(variant, value)             (variant).type = FSCRT_VT_LPUINT32, (variant).var.uint32PtrVar = (value);

#define FSCRT_Var_SetBooleanPtrValue(variant, value)    (variant).type = FSCRT_VT_LPBOOL, (variant).var.boolPtrVar = (value);

#define FSCRT_Var_SetFloatPtrValue(variant, value)              (variant).type = FSCRT_VT_LPFLOAT, (variant).var.floatPtrVar = (value);

#endif /* _FSCRT_DEF_STRUCTURE_VAR_ */

/*******************************************************************************/
/* String                                                                      */
/*                                                                             */
/* Byte string - UTF8, string encode and decode                                */
/*******************************************************************************/
#ifndef _FSCRT_DEF_STRUCTURE_BSTR_
#define _FSCRT_DEF_STRUCTURE_BSTR_

typedef struct _FSCRT_BSTR
{
        FS_LPSTR        str;
        FS_DWORD        len;
} FSCRT_BSTR;

#define FSCRT_BSTRD(str)                                                {str, sizeof(str) - 1}

#define FSCRT_BSTRC(v, str)                                             FSCRT_BSTR v = FSCRT_BSTRD(str)

#define FSCRT_BStr_InitConstString(v, s)                (v).str = s, (v).len = sizeof(s) - 1;

#endif /* _FSCRT_DEF_STRUCTURE_BSTR_ */

FS_RESULT       FSCRT_BStr_Init(FSCRT_BSTR* bstr);

FS_RESULT       FSCRT_BStr_Clear(FSCRT_BSTR* bstr);

FS_RESULT       FSCRT_BStr_SetLength(FSCRT_BSTR* bstr, FS_DWORD length);

FS_RESULT       FSCRT_BStr_Set(FSCRT_BSTR* bstr, FS_LPCSTR str, FS_DWORD length);
#define FSCRT_BStr_SetConstString(bstr, str)    FSCRT_BStr_Set(bstr, str, sizeof(str) - 1)

#define FSCRT_BStr_Copy(dstStr, srcStr)                 FSCRT_BStr_Set(dstStr, (srcStr)->str, (srcStr)->len)


#ifndef _FSCRT_DEF_STRUCTURE_ARRAY_
#define _FSCRT_DEF_STRUCTURE_ARRAY_

typedef struct _FSCRT_ARRAY
{
        FS_INT32 dataType;
        FS_DWORD count;
        FS_LPVOID data;

}FSCRT_ARRAY;

#endif /* _FSCRT_DEF_STRUCTURE_ARRAY_ */

FS_RESULT FSCRT_Array_Init(FSCRT_ARRAY* array, FS_INT32 dataType);

FS_RESULT FSCRT_Array_Clear(FSCRT_ARRAY* array);

/*******************************************************************************/
/* File stream                                                                 */
/*                                                                             */
/* File access, read or write, stream I/O                                      */
/*******************************************************************************/
#ifndef _FSCRT_DEF_HANDLE_FILE_
#define _FSCRT_DEF_HANDLE_FILE_

FSCRT_DEFINEHANDLE(FSCRT_FILE);

#endif /* _FSCRT_DEF_HANDLE_FILE_ */

#ifndef _FSCRT_DEF_STRUCTURE_FILESIZE_
#define _FSCRT_DEF_STRUCTURE_FILESIZE_

typedef struct _FSCRT_FILESIZE
{
        FS_DWORD        loSize;
        FS_DWORD        hiSize;
} FSCRT_FILESIZE;

#endif /* _FSCRT_DEF_STRUCTURE_FILESIZE_ */

#ifndef _FSCRT_DEF_HANDLER_FILE_
#define _FSCRT_DEF_HANDLER_FILE_

typedef struct _FSCRT_FILEHANDLER
{
        FS_LPVOID       clientData;

        void            (*Release)(FS_LPVOID clientData);

        FS_DWORD        (*GetSize)(FS_LPVOID clientData);

        FS_RESULT       (*ReadBlock)(FS_LPVOID clientData, FS_DWORD offset, FS_LPVOID buffer, FS_DWORD size);

        FS_RESULT       (*WriteBlock)(FS_LPVOID clientData, FS_DWORD offset, FS_LPCVOID buffer, FS_DWORD size);

        FS_RESULT       (*Flush)(FS_LPVOID clientData);

        FS_RESULT       (*Truncate)(FS_LPVOID clientData, FS_DWORD size);

} FSCRT_FILEHANDLER;

#endif /* _FSCRT_DEF_HANDLER_FILE_ */

FS_RESULT       FSCRT_File_Create(FSCRT_FILEHANDLER* fileStream, FSCRT_FILE* file);

#ifndef _FSCRT_DEF_HANDLE_LARGE_FILE_
#define _FSCRT_DEF_HANDLE_LARGE_FILE_

 typedef struct _FSCRT_FILEHANDLER_L
 {
         FS_LPVOID      clientData;

         void   (*Release)(FS_LPVOID clientData);

         FS_RESULT      (*GetSize)(FS_LPVOID clientData, FSCRT_FILESIZE* size);

         FS_RESULT      (*ReadBlock)(FS_LPVOID clientData, const FSCRT_FILESIZE* offset, FS_LPVOID buffer, const FSCRT_FILESIZE* size);

         FS_RESULT      (*WriteBlock)(FS_LPVOID clientData, const FSCRT_FILESIZE* offset, FS_LPCVOID buffer, const FSCRT_FILESIZE* size);
        
         FS_RESULT      (*Flush)(FS_LPVOID clientData);

         FS_RESULT      (*Truncate)(FS_LPVOID clientData, const FSCRT_FILESIZE* fileSize);

 } FSCRT_FILEHANDLER_L;

#endif /* _FSCRT_DEF_HANDLE_LARGE_FILE_ */

FS_RESULT       FSCRT_File_Create_L(FSCRT_FILEHANDLER_L* fileStream, FSCRT_FILE* file);


FS_RESULT       FSCRT_File_CreateCacheFile(FSCRT_FILEHANDLER* fileStream, FS_DWORD chunkSize, FS_DWORD chunkCount, FS_LPVOID buffer, FSCRT_FILE* file);

FS_RESULT       FSCRT_File_CreateFromMemory(FS_LPVOID buffer, FS_DWORD length, FSCRT_FILE* file);

#ifndef _FSCRT_DEF_MACRO_FILEMODE_
#define _FSCRT_DEF_MACRO_FILEMODE_

#define FSCRT_FILEMODE_WRITE            0

#define FSCRT_FILEMODE_READONLY         1

#define FSCRT_FILEMODE_TRUNCATE         2

#endif /* _FSCRT_DEF_MACRO_FILEMODE_ */

FS_RESULT       FSCRT_File_CreateFromFileName(const FSCRT_BSTR* fileName, FS_DWORD fileModes, FSCRT_FILE* file);

FS_RESULT       FSCRT_File_GetSize(FSCRT_FILE file, FSCRT_FILESIZE* fileSize);

FS_RESULT       FSCRT_File_SetRange(FSCRT_FILE file, const FSCRT_FILESIZE* offset, const FSCRT_FILESIZE* length);

FS_RESULT       FSCRT_File_ClearRange(FSCRT_FILE file);

FS_RESULT       FSCRT_File_Read(FSCRT_FILE file, FS_LPVOID buffer, const FSCRT_FILESIZE* size, FSCRT_FILESIZE* actualSize);

FS_RESULT       FSCRT_File_Write(FSCRT_FILE file, FS_LPVOID buffer, const FSCRT_FILESIZE* size);

FS_RESULT       FSCRT_File_Release(FSCRT_FILE file);

/*******************************************************************************/
/* Library management, license controls, log file and memory management        */
/*******************************************************************************/
#ifndef _FSCRT_DEF_MACRO_LICENSETYPE_
#define _FSCRT_DEF_MACRO_LICENSETYPE_

#define FSCRT_LICENSETYPE_INVALID                       FSCRT_ERRCODE_INVALIDLICENSE

#define FSCRT_LICENSETYPE_AUTHORIZED            0

#define FSCRT_LICENSETYPE_EVALUATION            1

#define FSCRT_LICENSETYPE_EXPIRED                       2

#endif /* _FSCRT_DEF_MACRO_LICENSETYPE_ */

#ifndef _FSCRT_DEF_HANDLER_MEMMGR_
#define _FSCRT_DEF_HANDLER_MEMMGR_

typedef struct _FSCRT_MEMMGRHANDLER
{
        FS_LPVOID       clientData;

        FS_LPVOID       (*Alloc)(FS_LPVOID clientData, FS_DWORD size);

        FS_LPVOID       (*Realloc)(FS_LPVOID clientData, FS_LPVOID ptr, FS_DWORD newSize);

        void            (*Free)(FS_LPVOID clientData, FS_LPVOID ptr);

} FSCRT_MEMMGRHANDLER;

#endif /* _FSCRT_DEF_HANDLER_MEMMGR_ */

FS_RESULT       FSCRT_Library_CreateMgr(FS_LPVOID memory, FS_DWORD size, FSCRT_MEMMGRHANDLER* memMgr);

FS_RESULT       FSCRT_Library_CreateDefaultMgr();

FS_RESULT       FSCRT_Library_GetMgr(FS_LPVOID* sdkMgr);

FS_RESULT       FSCRT_Library_SetMgr(FS_LPVOID sdkMgr);

void            FSCRT_Library_DestroyMgr();

FS_RESULT       FSCRT_Library_GetFixedMemSize(FS_DWORD* memSize);

FS_RESULT       FSCRT_License_UnlockLibrary(const FSCRT_BSTR* licenseKey, const FSCRT_BSTR* unlockCode);

FS_RESULT       FSCRT_License_GetType(FS_INT32* type);

FS_RESULT       FSCRT_Library_SetLogFile(FSCRT_FILE file);

FS_RESULT       FSCRT_Library_EnableJavaScript(FS_BOOL isEnabled);

FS_RESULT       FSCRT_Memory_Alloc(FS_DWORD size, FS_LPVOID* ptr);

FS_RESULT       FSCRT_Memory_Realloc(FS_LPVOID ptr, FS_DWORD newSize, FS_LPVOID* newPtr);

void            FSCRT_Memory_Free(FS_LPVOID ptr);

FS_RESULT       FSCRT_Library_GetVersion(FSCRT_BSTR* sdkVersion);

/*******************************************************************************/
/* Thread supports                                                             */
/*                                                                             */
/* Thread handler and finalization                                             */
/*******************************************************************************/
#ifndef _FSCRT_DEF_HANDLE_THREAD_
#define _FSCRT_DEF_HANDLE_THREAD_

FSCRT_DEFINEHANDLE(FSCRT_THREAD);

#endif /* _FSCRT_DEF_HANDLE_THREAD_ */

#ifndef _FSCRT_DEF_HANDLER_THREAD_
#define _FSCRT_DEF_HANDLER_THREAD_

typedef void (*FSCRT_CALLBACK_THREADFINALIZE)(FSCRT_THREAD thread);

typedef struct _FSCRT_THREADHANDLER
{
        FS_LPVOID               clientData;

        FSCRT_THREAD    (*GetCurrentThread)(FS_LPVOID clientData);

        void                    (*SetThreadFinalizeCallback)(FS_LPVOID clientData, FSCRT_CALLBACK_THREADFINALIZE callbackThreadFinalize);

} FSCRT_THREADHANDLER;

#endif /* _FSCRT_DEF_HANDLER_THREAD_ */

FS_RESULT       FSCRT_Library_SetThreadHandler(FSCRT_THREADHANDLER* threadHandler);

FS_RESULT       FSCRT_Library_SetCacheSize(FS_DWORD size);

/*******************************************************************************/
/* Common data structures                                                             */
/*                                                                             */
/* date & time, rectangle, matrix                                              */
/*******************************************************************************/
#ifndef _FSCRT_DEF_STRUCTURE_DATETIMEZONE_
#define _FSCRT_DEF_STRUCTURE_DATETIMEZONE_

typedef struct _FSCRT_DATETIMEZONE
{
        FS_UINT16               year;
        FS_UINT16               month;
        FS_UINT16               day;
        FS_UINT16               dayOfWeek;
        FS_UINT16               hour;
        FS_UINT16               minute;
        FS_UINT16               second;
        FS_UINT16               milliseconds;
        FS_INT16                tzHour;
        FS_UINT16               tzMinute;
} FSCRT_DATETIMEZONE;

#endif /* _FSCRT_DEF_STRUCTURE_DATETIMEZONE_ */

#ifndef _FSCRT_DEF_STRUCTURE_RECT_
#define _FSCRT_DEF_STRUCTURE_RECT_

typedef struct _FSCRT_RECT
{
        FS_INT32                left;
        FS_INT32                top;
        FS_INT32                right;
        FS_INT32                bottom;
} FSCRT_RECT;

#endif /* _FSCRT_DEF_STRUCTURE_RECT_ */

#ifndef _FSCRT_DEF_STRUCTURE_RECTF_
#define _FSCRT_DEF_STRUCTURE_RECTF_

typedef struct _FSCRT_RECTF
{
        FS_FLOAT                left;
        FS_FLOAT                top;
        FS_FLOAT                right;
        FS_FLOAT                bottom;
} FSCRT_RECTF;

#endif /* _FSCRT_DEF_STRUCTURE_RECTF_ */

#ifndef _FSCRT_DEF_STRUCTURE_QUADPOINTSF_
#define _FSCRT_DEF_STRUCTURE_QUADPOINTSF_

typedef struct _FSCRT_QUADPOINTSF
{
        FS_FLOAT        x1;
        FS_FLOAT        y1;
        FS_FLOAT        x2;
        FS_FLOAT        y2;
        FS_FLOAT        x3;
        FS_FLOAT        y3;
        FS_FLOAT        x4;
        FS_FLOAT        y4;
} FSCRT_QUADPOINTSF;

#endif /* _FSCRT_DEF_STRUCTURE_QUADPOINTSF_ */

#ifndef _FSCRT_DEF_STRUCTURE_MATRIX_
#define _FSCRT_DEF_STRUCTURE_MATRIX_

typedef struct _FSCRT_MATRIX
{
        FS_FLOAT        a;
        FS_FLOAT        b;
        FS_FLOAT        c;
        FS_FLOAT        d;
        FS_FLOAT        e;
        FS_FLOAT        f;
} FSCRT_MATRIX;

#endif /* _FSCRT_DEF_STRUCTURE_MATRIX_ */

FS_RESULT       FSCRT_Rect_IsAdjacent(const FSCRT_RECTF* rect1, const FSCRT_RECTF* rect2,
                                                                  FS_FLOAT alignmentTolerance, FS_FLOAT distanceTolerance, FS_DWORD direction,
                                                                  FS_BOOL* adjacent);

FS_RESULT       FSCRT_Matrix_Translate(FSCRT_MATRIX* matrix, FS_FLOAT offsetX, FS_FLOAT offsetY);

FS_RESULT       FSCRT_Matrix_Scale(FSCRT_MATRIX* matrix, FS_FLOAT scaleX, FS_FLOAT scaleY);

FS_RESULT       FSCRT_Matrix_Rotate(FSCRT_MATRIX* matrix, FS_FLOAT angle);

FS_RESULT       FSCRT_Matrix_Shear(FSCRT_MATRIX* matrix, FS_FLOAT alpha, FS_FLOAT beta);

FS_RESULT       FSCRT_Matrix_GetReverse(const FSCRT_MATRIX* srcMatrix, FSCRT_MATRIX* dstMatrix);

FS_RESULT       FSCRT_Matrix_Concat(FSCRT_MATRIX* dstMatrix, const FSCRT_MATRIX* srcMatrix);

FS_RESULT       FSCRT_Matrix_TransformPoint(const FSCRT_MATRIX* matrix, FS_INT32* x, FS_INT32* y);

FS_RESULT       FSCRT_Matrix_TransformPointF(const FSCRT_MATRIX* matrix, FS_FLOAT* x, FS_FLOAT* y);

FS_RESULT       FSCRT_Matrix_TransformRect(const FSCRT_MATRIX* matrix, FSCRT_RECT* rect);

FS_RESULT       FSCRT_Matrix_TransformRectF(const FSCRT_MATRIX* matrix, FSCRT_RECTF* rect);

/*******************************************************************************/
/* Path Data                                                                   */
/*******************************************************************************/
#ifndef _FSCRT_DEF_HANDLE_PATHDATA_
#define _FSCRT_DEF_HANDLE_PATHDATA_

FSCRT_DEFINEHANDLE(FSCRT_PATHDATA);

#endif /* _FSCRT_DEF_HANDLE_PATHDATA_ */

#ifndef _FSCRT_DEF_MACRO_POINTTYPE_
#define _FSCRT_DEF_MACRO_POINTTYPE_

#define FSCRT_POINTTYPE_CLOSEFIGURE             1

#define FSCRT_POINTTYPE_LINETO                  2

#define FSCRT_POINTTYPE_BEZIERTO                4

#define FSCRT_POINTTYPE_MOVETO                  6

#endif /* _FSCRT_DEF_MACRO_POINTTYPE_ */

#ifndef _FSCRT_DEF_MACRO_FILLMODE_
#define _FSCRT_DEF_MACRO_FILLMODE_

#define FSCRT_FILLMODE_NONE                             0

#define FSCRT_FILLMODE_ALTERNATE                1

#define FSCRT_FILLMODE_WINDING                  2

#endif /* _FSCRT_DEF_MACRO_FILLMODE_ */

FS_RESULT       FSCRT_PathData_Create(FSCRT_PATHDATA* pathData);

FS_RESULT       FSCRT_PathData_Clear(FSCRT_PATHDATA pathData);

FS_RESULT       FSCRT_PathData_Release(FSCRT_PATHDATA pathData);

FS_RESULT       FSCRT_PathData_CountPoints(FSCRT_PATHDATA pathData, FS_INT32* count);

FS_RESULT       FSCRT_PathData_AddPointsCount(FSCRT_PATHDATA pathData, FS_INT32 count);

FS_RESULT       FSCRT_PathData_GetPoint(FSCRT_PATHDATA pathData, FS_INT32 index, FS_FLOAT* x, FS_FLOAT* y, FS_INT32* pointType);

FS_RESULT       FSCRT_PathData_SetPoint(FSCRT_PATHDATA pathData, FS_INT32 index, FS_FLOAT x, FS_FLOAT y, FS_INT32 pointType);

FS_RESULT       FSCRT_PathData_RemovePoint(FSCRT_PATHDATA pathData, FS_INT32 index);

FS_RESULT       FSCRT_PathData_MoveTo(FSCRT_PATHDATA pathData, FS_FLOAT x, FS_FLOAT y);

FS_RESULT       FSCRT_PathData_LineTo(FSCRT_PATHDATA pathData, FS_FLOAT x, FS_FLOAT y);

FS_RESULT       FSCRT_PathData_CubicBezierTo(FSCRT_PATHDATA pathData, FS_FLOAT x1, FS_FLOAT y1, FS_FLOAT x2, FS_FLOAT y2, FS_FLOAT x3, FS_FLOAT y3);

FS_RESULT       FSCRT_PathData_AppendRect(FSCRT_PATHDATA pathData, const FSCRT_RECTF* rect);

FS_RESULT       FSCRT_PathData_AppendEllipse(FSCRT_PATHDATA pathData, const FSCRT_RECTF* rect);

FS_RESULT       FSCRT_PathData_CloseFigure(FSCRT_PATHDATA pathData);

FS_RESULT       FSCRT_PathData_Transform(FSCRT_PATHDATA pathData, const FSCRT_MATRIX* matrix);

/*******************************************************************************/
/* Private Data                                                                */
/*******************************************************************************/
#ifndef _FSCRT_DEF_CALLBACK_FREEPRIVATEDATA_
#define _FSCRT_DEF_CALLBACK_FREEPRIVATEDATA_

typedef void (*FSCRT_CALLBACK_FREEPRIVATEDATA)(FS_LPVOID data);

#endif /* _FSCRT_DEF_CALLBACK_FREEPRIVATEDATA_ */

FS_RESULT       FSCRT_Library_SetPrivateData(FS_LPVOID moduleID, FS_LPVOID data, FSCRT_CALLBACK_FREEPRIVATEDATA callbackFreePrivateData);

FS_RESULT       FSCRT_Library_GetPrivateData(FS_LPVOID moduleID, FS_LPVOID* data);

FS_RESULT       FSCRT_Library_RemovePrivateData(FS_LPVOID moduleID);

/*******************************************************************************/
/* Common objects                                                              */
/*******************************************************************************/
#ifndef _FSCRT_DEF_HANDLE_DOCUMENT_
#define _FSCRT_DEF_HANDLE_DOCUMENT_

FSCRT_DEFINEHANDLE(FSCRT_DOCUMENT);

#endif /* _FSCRT_DEF_HANDLE_DOCUMENT_ */

#ifndef _FSCRT_DEF_HANDLE_PAGE_
#define _FSCRT_DEF_HANDLE_PAGE_

FSCRT_DEFINEHANDLE(FSCRT_PAGE);

#endif /* _FSCRT_DEF_HANDLE_PAGE_ */

#ifndef _FSCRT_DEF_DEFINEHANDLE_ANNOT_
#define _FSCRT_DEF_DEFINEHANDLE_ANNOT_

FSCRT_DEFINEHANDLE(FSCRT_ANNOT);

#endif /* _FSCRT_DEF_DEFINEHANDLE_ANNOT_ */

#ifndef _FSCRT_DEF_MACRO_DOCUMENTTYPE_
#define _FSCRT_DEF_MACRO_DOCUMENTTYPE_

#define FSCRT_DOCUMENTTYPE_PDF                  1

#define FSCRT_DOCUMENTTYPE_FDF                  2

#define FSCRT_DOCUMENTTYPE_XFDF                 3

#endif /* _FSCRT_DEF_MACRO_DOCUMENTTYPE_ */

FS_RESULT       FSCRT_Doc_GetType(FSCRT_DOCUMENT document, FS_INT32* docType);

FS_RESULT       FSCRT_Page_GetDocument(FSCRT_PAGE page, FSCRT_DOCUMENT* document);

FS_RESULT       FSCRT_Annot_GetPage(FSCRT_ANNOT annot, FSCRT_PAGE* page);

/*******************************************************************************/
/* Progressive controls                                                           */
/*******************************************************************************/
#ifndef _FSCRT_DEF_HANDLE_PROGRESS_
#define _FSCRT_DEF_HANDLE_PROGRESS_

FSCRT_DEFINEHANDLE(FSCRT_PROGRESS);

#endif /* _FSCRT_DEF_HANDLE_PROGRESS_ */

#ifndef _FSCRT_DEF_HANDLER_PAUSE_
#define _FSCRT_DEF_HANDLER_PAUSE_

typedef struct _FSCRT_PAUSEHANDLER
{
        FS_LPVOID       clientData;

        FS_BOOL         (*NeedPauseNow)(FS_LPVOID clientData);

} FSCRT_PAUSEHANDLER;

#endif /* _FSCRT_DEF_HANDLER_PAUSE_ */

FS_RESULT       FSCRT_Progress_Continue(FSCRT_PROGRESS progress, FSCRT_PAUSEHANDLER* pause);

FS_RESULT       FSCRT_Progress_GetPercent(FSCRT_PROGRESS progress, FS_INT32* percent);

FS_RESULT       FSCRT_Progress_Release(FSCRT_PROGRESS progress);

FS_RESULT       FSCRT_Progress_SetProperty(FSCRT_PROGRESS progress, const FSCRT_BSTR* property, const FSCRT_VAR* values, FS_INT32 count);

/*******************************************************************************/
/* Font access                                                                 */
/*******************************************************************************/
#ifndef _FSCRT_DEF_HANDLE_FONT_
#define _FSCRT_DEF_HANDLE_FONT_



FSCRT_DEFINEHANDLE(FSCRT_FONT);

#endif /* _FSCRT_DEF_HANDLE_FONT_ */

#ifndef _FSCRT_DEF_MACRO_FONTSTYLE_
#define _FSCRT_DEF_MACRO_FONTSTYLE_

#define FSCRT_FONTSTYLE_FIXEDPITCH              1

#define FSCRT_FONTSTYLE_SERIF                   2

#define FSCRT_FONTSTYLE_SYMBOLIC                4

#define FSCRT_FONTSTYLE_SCRIPT                  8

#define FSCRT_FONTSTYLE_NONSYMBOLIC             32

#define FSCRT_FONTSTYLE_ITALIC                  64

#define FSCRT_FONTSTYLE_ALLCAP                  0x10000

#define FSCRT_FONTSTYLE_SMALLCAP                0x20000

#define FSCRT_FONTSTYLE_BOLD                    0x40000

#endif /* _FSCRT_DEF_MACRO_FONT_ */

#ifndef _FSCRT_DEF_MACRO_STDFONT_
#define _FSCRT_DEF_MACRO_STDFONT_

#define FSCRT_STDFONT_COURIER                   0

#define FSCRT_STDFONT_COURIER_B                 1

#define FSCRT_STDFONT_COURIER_BI                2

#define FSCRT_STDFONT_COURIER_I                 3

#define FSCRT_STDFONT_HELVETICA                 4

#define FSCRT_STDFONT_HELVETICA_B               5

#define FSCRT_STDFONT_HELVETICA_BI              6

#define FSCRT_STDFONT_HELVETICA_I               7

#define FSCRT_STDFONT_TIMES                             8

#define FSCRT_STDFONT_TIMES_B                   9

#define FSCRT_STDFONT_TIMES_BI                  10

#define FSCRT_STDFONT_TIMES_I                   11

#define FSCRT_STDFONT_SYMBOL                    12

#define FSCRT_STDFONT_ZAPFDINGBATS              13

#endif /* _FSCRT_DEF_MACRO_STDFONT_ */

#ifndef _FSCRT_DEF_MACRO_CHARSET_
#define _FSCRT_DEF_MACRO_CHARSET_

#define FSCRT_CHARSET_ANSI                              0

#define FSCRT_CHARSET_DEFAULT                   1

#define FSCRT_CHARSET_SYMBOL                    2

#define FSCRT_CHARSET_SHIFTJIS                  128

#define FSCRT_CHARSET_HANGEUL                   129

#define FSCRT_CHARSET_GB2312                    134

#define FSCRT_CHARSET_CHINESEBIG5               136

#define FSCRT_CHARSET_THAI                              222

#define FSCRT_CHARSET_EASTEUROPE                238

#define FSCRT_CHARSET_RUSSIAN                   204

#define FSCRT_CHARSET_GREEK                             161

#define FSCRT_CHARSET_TURKISH                   162

#define FSCRT_CHARSET_HEBREW                    177

#define FSCRT_CHARSET_ARABIC                    178

#define FSCRT_CHARSET_BALTIC                    186

#endif /* _FSCRT_DEF_MACRO_CHARSET_ */

#ifndef _FSCRT_DEF_HANDLER_FONTMAPPER_
#define _FSCRT_DEF_HANDLER_FONTMAPPER_

typedef struct _FSCRT_FONTMAPPERHANDLER
{
        FS_LPVOID       clientData;
        
        FS_RESULT       (*MapFont)(FS_LPVOID clientData, FS_LPCSTR fontName,
                                                   FS_DWORD fontStyles, FS_INT32 weight, FS_INT32 charset,
                                                   FSCRT_FILE* fontFile, FS_INT32* faceIndex);
} FSCRT_FONTMAPPERHANDLER;

#endif /* _FSCRT_DEF_HANDLER_FONTMAPPER_ */

FS_RESULT       FSCRT_Library_SetFontMapperHandler(FSCRT_FONTMAPPERHANDLER* fontMapperHandler);

FS_RESULT       FSCRT_Library_AddFontFile(FSCRT_FILE fontFile);

FS_RESULT               FSCRT_Library_LoadSystemFonts();

#ifndef _FSCRT_DEF_STRUCTURE_FONTFACE_
#define _FSCRT_DEF_STRUCTURE_FONTFACE_

typedef struct _FSCRT_FONTFACE
{
        FSCRT_BSTR              faceName;
        FS_BOOL                 bold;
        FS_BOOL                 italic;
} FSCRT_FONTFACE;

#endif /* _FSCRT_DEF_STRUCTURE_FONTFACE_ */

FS_RESULT       FSCRT_Font_Create(const FSCRT_BSTR* fontName, FS_DWORD fontStyles, FS_INT32 weight, FS_INT32 charset, FSCRT_FONT* font);

FS_RESULT       FSCRT_Font_CreateStandard(FS_INT32 fontID, FSCRT_FONT* font);

FS_RESULT       FSCRT_Font_EnumFaces(FSCRT_FILE fontFile, FSCRT_FONTFACE* faces, FS_INT32* count);

FS_RESULT       FSCRT_Font_CreateFromFile(FSCRT_FILE fontFile, FS_INT32 faceIndex, FS_INT32 charset, FSCRT_FONT* font);

FS_RESULT       FSCRT_Font_Release(FSCRT_FONT font);

FS_RESULT       FSCRT_Font_GetName(FSCRT_FONT font, FSCRT_BSTR* fontName);

FS_RESULT       FSCRT_Font_IsBold(FSCRT_FONT font, FS_BOOL* bold);

FS_RESULT       FSCRT_Font_IsItalic(FSCRT_FONT font, FS_BOOL* italic);

FS_RESULT       FSCRT_Font_GetAscent(FSCRT_FONT font, FS_INT32* ascent);

FS_RESULT       FSCRT_Font_GetDescent(FSCRT_FONT font, FS_INT32* descent);

FS_RESULT  FSCRT_Font_GetCharBBox(FSCRT_FONT font, FS_DWORD unicode, FSCRT_RECT* bbox);

FS_RESULT  FSCRT_Font_GetCharWidth(FSCRT_FONT font, FS_DWORD unicode, FS_FLOAT* width);

/*******************************************************************************/
/* Common definitions                                                          */
/*                                                                             */
/* Macros for search flags, ciphers                                            */
/*******************************************************************************/
#ifndef _FSCRT_DEF_MACRO_SEARCHFLAG_
#define _FSCRT_DEF_MACRO_SEARCHFLAG_

#define FSCRT_SEARCHFLAG_MATCHCASE                      1

#define FSCRT_SEARCHFLAG_MATCHWHOLEWORD         2

#define FSCRT_SEARCHFLAG_CONSECUTIVE            4

#endif /* _FSCRT_DEF_MACRO_SEARCHFLAG_ */

#ifndef _FSCRT_DEF_MACRO_CIPHER_
#define _FSCRT_DEF_MACRO_CIPHER_

#define FSCRT_CIPHER_NONE               0

#define FSCRT_CIPHER_RC4                1

#define FSCRT_CIPHER_AES                2

#endif /* _FSCRT_DEF_MACRO_CIPHER_ */

#ifndef _FSCRT_DEF_MACRO_OBJECTTYPE_
#define _FSCRT_DEF_MACRO_OBJECTTYPE_

#define FSCRT_OBJECTTYPE_UNKNOWN                0

#define FSCRT_OBJECTTYPE_DOCUMENT               1

#define FSCRT_OBJECTTYPE_SECTION                2

#define FSCRT_OBJECTTYPE_PAGE                   3

#define FSCRT_OBJECTTYPE_ANNOT                  4

#define FSCRT_OBJECTTYPE_FORM                   5

#define FSCRT_OBJECTTYPE_FORMFIELD              6

#define FSCRT_OBJECTTYPE_FORMCONTROL    7

#define FSCRT_OBJECTTYPE_SIGNATURE              8

#define FSCRT_OBJECTTYPE_PSI                    9

#endif /* _FSCRT_DEF_MACRO_OBJECTTYPE_ */

#ifndef _FSCRT_DEF_MACRO_PAGEROTATION_
#define _FSCRT_DEF_MACRO_PAGEROTATION_

#define FSCRT_PAGEROTATION_0            0

#define FSCRT_PAGEROTATION_90           1

#define FSCRT_PAGEROTATION_180          2

#define FSCRT_PAGEROTATION_270          3

#endif /* _FSCRT_DEF_MACRO_PAGEROTATION_ */

#ifndef _FSCRT_DEF_MACRO_LANGUAGE_
#define _FSCRT_DEF_MACRO_LANGUAGE_

#define FSCRT_LANGUAGE_UNK              0

#define FSCRT_LANGUAGE_CHS              1

#define FSCRT_LANGUAGE_CHT              2

#define FSCRT_LANGUAGE_DAN              3

#define FSCRT_LANGUAGE_DEU              4

#define FSCRT_LANGUAGE_ENU              5

#define FSCRT_LANGUAGE_ESP              6

#define FSCRT_LANGUAGE_FRA              7

#define FSCRT_LANGUAGE_ITA              8

#define FSCRT_LANGUAGE_KOR              9

#define FSCRT_LANGUAGE_JPN              10

#define FSCRT_LANGUAGE_NLD              11

#define FSCRT_LANGUAGE_NOR              12

#define FSCRT_LANGUAGE_PTB              13

#define FSCRT_LANGUAGE_SUO              14

#define FSCRT_LANGUAGE_SVE              15

#endif /* _FSCRT_DEF_MACRO_LANGUAGE_ */

#ifndef _FSCRT_DEF_DEFINEHANDLE_ARCHIVE_
#define _FSCRT_DEF_DEFINEHANDLE_ARCHIVE_

FSCRT_DEFINEHANDLE(FSCRT_ARCHIVE);

#endif /* _FSCRT_DEF_DEFINEHANDLE_ARCHIVE_ */

FS_RESULT       FSCRT_Archive_Create(FSCRT_ARCHIVE* archive);

FS_RESULT       FSCRT_Archive_Release(FSCRT_ARCHIVE archive);

FS_RESULT       FSCRT_Archive_GetData(FSCRT_ARCHIVE archive, FSCRT_BSTR* data);
 
FS_RESULT       FSCRT_Archive_LoadData(FSCRT_ARCHIVE archive, const FSCRT_BSTR* data);

#ifndef _FSCRT_DEF_HANDLE_POSITION_
#define _FSCRT_DEF_HANDLE_POSITION_

FSCRT_DEFINEHANDLE(FSCRT_POSITION);
#endif /* _FSCRT_DEF_HANDLE_POSITION_ */

#ifdef __cplusplus
};
#endif
 /* group FSBASE */

#endif /* _FSCRT_BASE_R_H_ */