/* LTTYP.H - basic data types Copyright (c) 1991-2000 LEAD Technologies, Inc. All Rights Reserved. */ #ifndef _LTTYP_H_ #define _LTTYP_H_ #if !defined(FOR_DOTNET) #ifdef FOR_LINUX #include "windows.h" #endif #include "ltsys.h" #define _HEADER_ENTRY_ #include "ltpck.h" #pragma warning (error:4020) #pragma warning (error:4021) #ifdef FOR_UNICODE typedef TCHAR L_TCHAR; #else typedef char L_TCHAR; #endif #define L_TEXT TEXT typedef WCHAR L_WCHAR; /* 16-bit UNICODE character */ typedef char L_CHAR; /* signed 8-bit integer */ typedef unsigned char L_UCHAR; /* unsigned 8-bit integer */ typedef short L_INT16; /* signed 16-bit integer */ typedef unsigned short L_UINT16;/* unsigned 16-bit integer */ typedef long L_INT32; /* signed 32-bit integer */ typedef unsigned long L_UINT32; /* unsigned 32-bit integer */ #ifndef FOR_WIN typedef LONGLONG L_INT64; /* signed 64-bit integer */ typedef DWORDLONG L_UINT64; /* unsigned 64-bit integer */ #endif typedef int L_INT; /* signed integer 16-bits or larger */ typedef unsigned L_UINT; /* unsigned integer 16-bits or larger */ typedef void L_VOID; /* void */ typedef L_UINT L_BOOL; /* boolean */ typedef L_UINT L_BITFIELD; /* bit field */ typedef float L_FLOAT; /* floating point number */ typedef double L_DOUBLE; /* double precision floating point number */ typedef RGBQUAD L_RGBQUAD; /* RGBQUAD structure */ typedef HANDLE L_HANDLE; typedef HANDLE L_OBJECT; typedef L_INT L_HFILE; typedef L_INT L_SEEKORIGIN; // ICC stuff /* 7-Bit ASCII - must be terminated by NULL */ typedef L_UCHAR L_Icc7BitAscii; /* Fixed Numbers */ typedef L_INT32 L_IccS15Fixed16Number; // fixed signed 4bytes, with 16 fractional bits typedef L_UINT32 L_IccU16Fixed16Number; // fixed unsigned 4bytes, with 16 fractional bits typedef L_UINT16 L_IccU1Fixed15Number; // fixed unsigned 2bytes, with 15 fractional bits typedef L_UINT16 L_IccU8Fixed8Number; // fixed unsigned 2bytes, with 8 fractional bits /* Unsigned Integer Numbers */ typedef L_UINT16 L_IccUInt16Number; typedef L_UINT32 L_IccUInt32Number; typedef L_UINT64 L_IccUInt64Number; typedef L_UCHAR L_IccUInt8Number; /* Signed Integer Numbers - not in specification but might be needed */ typedef L_CHAR L_IccInt8Number; typedef L_INT16 L_IccInt16Number; typedef L_INT32 L_IccInt32Number; typedef L_INT64 L_IccInt64Number; typedef L_INT32 L_IccSignature; #define L__PIN L_FAR #define L__GC #define L__NOGC #define L__VALUE #define L_PRIVATE #define L_PUBLIC #define DEFINE_DELEGATE(retType, funcType) typedef retType (pEXT_CALLBACK funcType) #define DELEGATEPTR(p) p #define L_VALARRAY(TYPE, VAR) TYPE L_FAR* (VAR) #define L_REFARRAY(TYPE, VAR) TYPE L_FAR* (VAR) #define L_REFARRAY_ELEM(VAL) (&VAL) #define L_REFARRAY_DECLARE(TYPE, VAR, COUNT) TYPE VAR[COUNT] #define L_VALARRAY_INPLACE L_REFARRAY_DECLARE #define L_VALARRAY_DECLARE L_REFARRAY_DECLARE #define L_REFARRAY_INPLACE L_REFARRAY_DECLARE #define L_VALARRAY_FARALLOCINIT(TYPE, COUNT) (TYPE L_FAR*)FARALLOCINIT(sizeof(TYPE), COUNT) #define L_VALARRAY_FARALLOC(TYPE, COUNT) (TYPE L_FAR*)FARALLOC(sizeof(TYPE), COUNT) #define L_REFARRAY_FARALLOC(ARRAY, TYPE, COUNT) ARRAY = L_VALARRAY_FARALLOC(TYPE, COUNT) #define L_VALARRAY_GLOBALALLOC(TYPE, COUNT) (TYPE L_FAR*)GLOBALALLOC(sizeof(TYPE), COUNT) #define L_REFARRAY_GLOBALALLOC(ARRAY, TYPE, COUNT) ARRAY = L_VALARRAY_GLOBALALLOC(TYPE, COUNT) #ifdef FOR_WIN #define L_FAR _far /* segmented memory attribute < 64K */ #define L_HUGE _huge /* segmented memory attribute > 64K */ #define L_EXPORT _export /* export attribute */ #define L_PASCAL _pascal /* pascal calling convention */ #elif defined(FOR_WIN32) || defined(FOR_LINUX) || defined(FOR_WIN64) #define L_FAR /* segmented memory attribute < 64K */ #define L_HUGE /* segmented memory attribute > 64K */ // #define L_EXPORT /* export attribute */ #define L_EXPORT __stdcall /* export attribute */ #define L_PASCAL /* pascal calling convention */ #endif typedef L_VOID L_FAR* pOBJECT; typedef L_TCHAR L_FAR* L_STRING; #ifdef FOR_JUSTLIB #define DLL_EXPORT EXTERN_C __declspec(dllexport) #else #define DLL_EXPORT #endif #if defined(FOR_WIN) || defined(FOR_WIN32) || defined(FOR_WIN64) #define EXT_FUNCTION WINAPI #define pEXT_FUNCTION EXT_FUNCTION L_FAR * #ifndef FOR_LINUX #define EXT_CALLBACK __stdcall L_FAR #else #define EXT_CALLBACK #endif #define pEXT_CALLBACK EXT_CALLBACK L_FAR * #endif /* defined(FOR_WIN) || defined(FOR_WIN32) */ #define L_MAXPATH 264 // 64-bit needs this to be multiple of 8 // macro which sets the size of the structure without checking for NULL pointer #define SET_SIZE(PSTRUCTPTR) (PSTRUCTPTR)->uStructSize = sizeof(*PSTRUCTPTR) // macro which sets the size of the structure. If the pointer is NULL, it returns ERROR_NULL_PTR #define SAFE_SET_SIZE(PSTRUCTPTR) \ if(!PSTRUCTPTR) \ return ERROR_NULL_PTR; \ SET_SIZE(PSTRUCTPTR) // macro which checks the structure size without checking for NULL pointer #define CHECK_SIZE(PSTRUCTPTR) if((PSTRUCTPTR)->uStructSize != sizeof(*PSTRUCTPTR)) return ERROR_INVALID_STRUCT_SIZE #define CHECK_SIZE_RET(PSTRUCTPTR, ret) if((PSTRUCTPTR)->uStructSize != sizeof(*PSTRUCTPTR)) return ret // macro which checks the size of the structure. If the pointer is NULL, it returns ERROR_NULL_PTR #define SAFE_CHECK_SIZE(PSTRUCTPTR) \ if(!PSTRUCTPTR) \ return ERROR_NULL_PTR; \ CHECK_SIZE(PSTRUCTPTR) #define CHECK_SIZE2_RET(PSTRUCTPTR, USTRUCTSIZE, ret) \ if(USTRUCTSIZE != sizeof(*PSTRUCTPTR)) \ return ret; \ if(PSTRUCTPTR) \ (PSTRUCTPTR)->uStructSize = USTRUCTSIZE // macro which compares the structure size with the user-specified size // if the pointer is non-NULL, it also sets the structure size accordingly #define CHECK_SIZE2(PSTRUCTPTR, USTRUCTSIZE) CHECK_SIZE2_RET(PSTRUCTPTR, USTRUCTSIZE, ERROR_INVALID_STRUCT_SIZE) #define SAFE_CHECK_SIZE2(PSTRUCTPTR, USTRUCTSIZE) \ if(!PSTRUCTPTR) \ return ERROR_NULL_PTR; \ CHECK_SIZE2_RET(PSTRUCTPTR, USTRUCTSIZE, ERROR_INVALID_STRUCT_SIZE) // macros which checks the structure size without checking for NULL pointer // these macros are for use with structures that have changed once // they allow for only two possible sizes. #define CHECK_SIZE_NEW_RET(PSTRUCTPTR, structname, member, ret) if( (PSTRUCTPTR)->uStructSize != sizeof(*PSTRUCTPTR) && (PSTRUCTPTR)->uStructSize != offsetof(structname, member) ) return ret #define CHECK_SIZE_NEW(PSTRUCTPTR, structname, member) CHECK_SIZE_NEW_RET(PSTRUCTPTR, structname, member, ERROR_INVALID_STRUCT_SIZE) #define CHECK_SIZE2_NEW_RET(PSTRUCTPTR, structname, member, USTRUCTSIZE, ret) \ if( USTRUCTSIZE != sizeof(*PSTRUCTPTR) && USTRUCTSIZE != offsetof(structname, member) ) \ return ret; \ if(PSTRUCTPTR) \ (PSTRUCTPTR)->uStructSize = USTRUCTSIZE #define CHECK_SIZE2_NEW(PSTRUCTPTR, structname, member, USTRUCTSIZE) CHECK_SIZE2_NEW_RET(PSTRUCTPTR, structname, member, USTRUCTSIZE, ERROR_INVALID_STRUCT_SIZE) #define L_START_PUBLIC_STRUCT2(STRUCTNAME) typedef struct _##STRUCTNAME { #define L_END_STRUCT2(STRUCTNAME) } STRUCTNAME, L_FAR*p##STRUCTNAME #define L__PIN L_FAR #define L__GC #define L__NOGC #define L__VALUE #define L_PRIVATE #define L_PUBLIC #define L_EOF EOF typedef WPARAM L_WPARAM; typedef LPARAM L_LPARAM; #define W_FARPROC FARPROC #define W_WINAPI WINAPI #define L_MAX_PATH MAX_PATH #define L_DISPLAYPAIR HDC #define L_DISPLAYPAIR_DC(p) p #define L_DISPLAYPAIR_GRAPHICS(p) p #define L_DISPLAYPAIR_ATTRIBUTES(p) NULL #define L_START_UNION union { #define L_END_UNION }; #define L_FORWARD_PRIVATE_CLASS(name) typedef struct _##name name #define L_START_PRIVATE_CLASS(name) typedef struct _##name { #define L_START_PUBLIC_CLASS_TAG(name) typedef struct tag##name { #define L_FORWARD_PUBLIC_CLASS L_FORWARD_PRIVATE_CLASS #define L_START_PUBLIC_CLASS L_START_PRIVATE_CLASS #define L_END_CLASS(name) } name, * p##name #define L_FORWARD_PRIVATE_STRUCT L_FORWARD_PRIVATE_CLASS #define L_START_PRIVATE_STRUCT L_START_PRIVATE_CLASS #define L_START_PRIVATE_STRUCT_PACKED L_START_PRIVATE_CLASS #define L_START_PRIVATE_CLASS_PACKED L_START_PRIVATE_CLASS #define L_FORWARD_PUBLIC_STRUCT L_FORWARD_PUBLIC_CLASS #define L_START_PUBLIC_STRUCT L_START_PUBLIC_CLASS #define L_START_PUBLIC_STRUCT_PACKED L_START_PUBLIC_CLASS #define L_START_PUBLIC_CLASS_PACKED L_START_PUBLIC_CLASS #define L_STRUCT_ARRAY(type, name, size) type name[size] #define L_END_STRUCT L_END_CLASS #define L_DECLARE_PRIVATE_CLASS class #define SIZEOFBITMAPHANDLE sizeof(BITMAPHANDLE) #define SIZEOFLOADFILEOPTION sizeof(LOADFILEOPTION) #define SIZEOFRGBQUAD sizeof(RGBQUAD) #define SIZEOFFILEINFO sizeof(FILEINFO) #define SIZEOFBITMAPINFOHEADER sizeof(BITMAPINFOHEADER) #define SIZEOFGUID sizeof(GUID) #define SIZEOFJ2KFILEINFODISPATCH sizeof(J2KFILEINFODISPATCH) #define SIZEOFLAYERINFO sizeof(LAYERINFO) #define pOBJECT L_VOID L_FAR* #define MYSIZEOF(v) sizeof(v) #define ZERO_STRUCT(pSTRUCT) FMEMSET(pSTRUCT, 0, sizeof(*pSTRUCT)) #define ZERO_STRUCT_NEW(pSTRUCT, uSTRUCTSIZE) FMEMSET(pSTRUCT, 0, uSTRUCTSIZE) #define L_INVALID_FILE -1 #define L_INVALID_HANDLE_VALUE INVALID_HANDLE_VALUE #define L_INVALID_FILE_HANDLE (HANDLE)-1 #define L_BUFFERSIZEOF(p) sizeof(p) #define NEWRGBQUADS(rgb, count) RGBQUAD rgb[count] #define NEWRGBQUADSPTRGLOBAL(rgb, count) RGBQUAD* rgb = (RGBQUAD L_FAR *)GLOBALALLOC(sizeof(RGBQUAD), count) #define NEWRGBQUADSPTRFAR(rgb, count) RGBQUAD* rgb = (RGBQUAD L_FAR *)FARALLOC(sizeof(RGBQUAD), count) #define NEWRGBQUADSPTRNODECLAREGLOBAL(rgb, count) rgb = (RGBQUAD L_FAR *)GLOBALALLOC(sizeof(RGBQUAD), count) #define NEWRGBQUADSPTRNODECLAREFAR(rgb, count) rgb = (RGBQUAD L_FAR *)FARALLOC(sizeof(RGBQUAD), count) #define RESETRGBQUADS(rgb, count) FMEMSET(rgb, 0, (count) * sizeof(RGBQUAD)) #define RESETRGBQUADSARRAYPTR RESETRGBQUADS #define RESETRGBQUADSARRAY(rgb) RESETRGBQUADSARRAYPTR(rgb, sizeof(rgb) / sizeof(RGBQUAD)) #define NEWRGBQUAD(b, g, r, reserved) {b, g, r, reserved} #define COPYRGBQUADS(rgbDst, rgbSrc, count) FMEMCPY(rgbDst, rgbSrc, (count) * sizeof(RGBQUAD)) #define COPYRGBQUADSARRAY(rgbDst, rgbSrc) FMEMCPY(rgbDst, rgbSrc, sizeof(rgbSrc)) #define DEFAULT_ALPHA_VALUE 0x00 #define L_HANDLE_OK(handle) ((handle) != NULL) #define FARALLOC_VALARRAY(TYPE, COUNT) (TYPE L_FAR*)FARALLOC(COUNT, sizeof(TYPE)) #define FARALLOC_REFARRAY(VAL, TYPE, COUNT) VAL = (TYPE L_FAR*)FARALLOC(COUNT, sizeof(TYPE)) #define FARALLOC_STRUCT(TYPE) (TYPE L_FAR*)FARALLOC(sizeof(TYPE), 1) #define FARALLOC_STRUCT_CONSTRUCTOR(TYPE, VAL) FARALLOC_STRUCT(TYPE) #define FARALLOCINIT_STRUCT(TYPE) (TYPE L_FAR*)FARALLOCINIT(sizeof(TYPE), 1) #define FARFREE_STRUCT FARFREE #define FARALLOCINIT_STRUCT(TYPE) (TYPE L_FAR*)FARALLOCINIT(sizeof(TYPE), 1) #define MANAGED_FARFREE FARFREE #define MANAGED_FARFREE_CHECK(p) if(p) FARFREE(p) #define MANAGED_GLOBALFREE GLOBALFREE #define UNMANAGED_GLOBALALLOC GLOBALALLOC #define UNMANAGED_GLOBALFREE GLOBALFREE #define UNMANAGED_GLOBALREALLOC GLOBALREALLOC #define UNMANAGED_GLOBALALLOCINIT GLOBALALLOCINIT #define UNMANAGED_GLOBALREALLOCINIT GLOBALREALLOCINIT #define UNMANAGED_FARALLOC FARALLOC #define UNMANAGED_FARFREE FARFREE #define UNMANAGED_FARREALLOC FARREALLOC #define UNMANAGED_FARALLOCINIT FARALLOCINIT #define INIT_STRUCT(TYPE, p) FMEMSET(p, 0, sizeof(TYPE)) #define FARALLOC_BITMAPHANDLE() (pBITMAPHANDLE)FARALLOC(sizeof(BITMAPHANDLE), 1) #define GLOBALALLOC_VALARRAY(TYPE, COUNT) (TYPE L_FAR*)GLOBALALLOC(COUNT, sizeof(TYPE)) #define GC_VALARRAY(TYPE, VAR, COUNT) TYPE VAR[COUNT] #define GC_REFARRAY(TYPE, VAR, COUNT) TYPE VAR[COUNT] #define COPY_BITMAPHANDLE(dest, src) FMEMCPY(dest, src, sizeof(BITMAPHANDLE)) #define COPY_BITMAPHANDLE_DIRECT(dest, src) *dest = *src #define NEW_STRUCT_PTR(type, p) type p; type* STRUCT_PTR_NAME(p) = &p #define NEW_STRUCT_PTR2(type, p) type STRUCT_NAME(p); type* p = &STRUCT_NAME(p) #define NEW_STRUCT_CONSTRUCTOR(type, p, arg) NEW_STRUCT_PTR2(type, p) #define MAKE_HANDLE(val) (HANDLE)(val) #define COPY_STRUCT(pDST, pSRC) *pDST = *pSRC #define INVOKE(delegateptr) delegateptr #define DYNAMIC_CAST(TYPE, VAR) (TYPE)VAR #define REINTERPRET_CAST(TYPE, VAR) (TYPE)VAR #define CAST_DISPATCH(TYPEDISPATCH, pTypeDispatch, pDISPATCH) \ p##TYPEDISPATCH pTypeDispatch = (p##TYPEDISPATCH)pDISPATCH; UNREFERENCED_PARAMETER(pTypeDispatch); #define DUMMY_DISPATCH(pREDIRECTS) NEW_STRUCT_CONSTRUCTOR(DUMMYDISPATCH, pDispatch, pREDIRECTS); UNREFERENCED_PARAMETER(pDispatch); UNREFERENCED_PARAMETER(pREDIRECTS) #define DUMMY_DISPATCH2(pREDIRECTS) NEW_STRUCT_CONSTRUCTOR(DUMMYDISPATCH, pDummyDispatch, pREDIRECTS); UNREFERENCED_PARAMETER(pDummyDispatch) #define L_COLORPALETTETOHPALETTE(hPalette) hPalette #define MAKE_DELEGATE(TYPE, func) func #define MAKE_DELEGATE2(TYPE, CLASS, func) func #define L_GCROOT(p) p typedef MSG W_MSG; #if !defined(_WIN32_WCE) typedef WNDCLASSEX W_WNDCLASSEX; #endif /* _WIN32_WCE */ #define LEAD_TEXT TEXT #define W_MAKEINTRESOURCEA MAKEINTRESOURCEA #define W_MAKEINTRESOURCEW MAKEINTRESOURCEW #define W_WINAPI WINAPI typedef HANDLE W_HANDLE; typedef HCURSOR W_HCURSOR; typedef HFONT W_HFONT; typedef HBRUSH W_HBRUSH; typedef HPEN W_HPEN; typedef HPALETTE W_HPALETTE; typedef HWND W_HWND; typedef HDC W_HDC; typedef HRGN W_HRGN; typedef HBITMAP W_HBITMAP; typedef LOGFONT W_LOGFONT; typedef LOGFONTA W_LOGFONTA; typedef POINT W_POINT; typedef SIZE W_SIZE; typedef TEXTMETRICA W_TEXTMETRICA; typedef LOGBRUSH W_LOGBRUSH; typedef LOGPEN W_LOGPEN; typedef HINSTANCE W_HINSTANCE; #define W_GET_HANDLE(p) p #define W_WNDPROC WNDPROC #define W_DLGPROC DLGPROC #define W_WNDENUMPROC WNDENUMPROC #define W_TIMERPROC TIMERPROC typedef DLGTEMPLATE W_DLGTEMPLATE; typedef W_DLGTEMPLATE* W_pDLGTEMPLATE; typedef DLGITEMTEMPLATE W_DLGITEMTEMPLATE; typedef W_DLGITEMTEMPLATE* W_pDLGITEMTEMPLATE; typedef SYSTEMTIME W_SYSTEMTIME; typedef PALETTEENTRY W_PALETTEENTRY; typedef LOGPALETTE W_LOGPALETTE; typedef RECT W_WINRECT; #if !defined(_WIN32_WCE) typedef ENHMETAHEADER W_ENHMETAHEADER; typedef METARECORD W_METARECORD; typedef EMR W_EMR; typedef EMREOF W_EMREOF; typedef EMRSTRETCHDIBITS W_EMRSTRETCHDIBITS; #endif /* _WIN32_WCE */ #define WinGetTempFileName GetTempFileName typedef MEMORYSTATUS W_MEMORYSTATUS; typedef SECURITY_ATTRIBUTES W_SECURITY_ATTRIBUTES; typedef RGNDATAHEADER W_RGNDATAHEADER; typedef RGNDATA W_RGNDATA; #if !defined(L_SEEK_SET) #define L_SEEK_SET SEEK_SET #define L_SEEK_CUR SEEK_CUR #define L_SEEK_END SEEK_END #endif #define MY_SEEK_CUR SEEK_CUR #define MY_SEEK_SET SEEK_SET #define MY_SEEK_END SEEK_END #define L_CREATE _O_CREAT #define L_TRUNC _O_TRUNC #define L_OPEN 0 #define L_RDONLY _O_RDONLY #define L_WRONLY _O_WRONLY #define L_RDWR _O_RDWR #define L_SHARE_READWRITE (S_IWRITE | S_IREAD) #define L_SHARE_WRITE S_IWRITE #define L_SHARE_READ S_IREAD #define L_SHARE_NONE 0 /*---------- L_UCHAR_PTR defines start here -----------------*/ /* Define L_UCHAR_PTR, which is used to represent pointers into dotnet arrays. For Win32, this is simply L_UCHAR L_FAR*. For .NET, this is a L_UCHAR buf L__GC[] and an offset into buf. */ typedef L_UCHAR L_FAR* L_UCHAR_PTR; #define L_UCHAR_PTR_VAL(PTR, INDEX) PTR[INDEX] #define L_UCHAR_PTR_INC(PTR) PTR++ #define RETURN_UCHAR_PTR(BUF, OFFSET) return &BUF[OFFSET] #define RETURN_NULL_UCHAR_PTR return NULL #define L_UCHAR_PTR_RESET(PTR) PTR = NULL #define L_UCHAR_PTR_SET(PTR, VAL) PTR = VAL #define L_UCHAR_PTR_SET_FROM_UCHAR_PTR(PTRDEST, PTRSRC, VAL) PTRDEST = &PTRSRC[VAL] #define L_UCHAR_PTR_SET_FROM_UCHAR_ARRAY(PTRDEST, PTRSRC, VAL) PTRDEST = &PTRSRC[VAL] #define L_UCHAR_PTR_OK(PTR) PTR != NULL /*---------- L_UCHAR_PTR defines end here -----------------*/ /*---------- array of arrays defines start here -----------------*/ /* defines used for array of arrays */ /* STRUCT_ARRAY_TYPE will define STRUCT_ARRAY type */ #define DEFINE_STRUCT_ARRAY_TYPE(STRUCT) \ struct STRUCT##_ARRAY \ { \ STRUCT L_FAR*array; \ } /*---------- array of arrays defines start here -----------------*/ #define L_BITMAP_IS_CONVENTIONAL_MEMORY(pBitmap) ((pBitmap)->Flags.ConventionalMemory) #define L_BITMAP_MANAGED_MEMORY_FLAG(pBitmap) ((pBitmap)->Flags.ConventionalMemory) #define L_BITMAP_UNMANAGED_MEMORY_FLAG(pBitmap) ((pBitmap)->Flags.ConventionalMemory) #define L_BITMAP_MANAGED_MEMORY(pBitmap) ((pBitmap)->Addr.Windows) #define L_BITMAP_UNMANAGED_MEMORY(pBitmap) ((pBitmap)->Addr.Windows) #define L_BITMAP_DATA_OFFSET(pBitmap) ((pBitmap)->DataOffset) // ka: remove this #define PIN(p) p##_pin #define L_PIN(p) p##_pin #define L_BITMAP_MEMORY_DECLARE(type, pBitmap, name) \ type* name##_pin = NULL; \ type* name = NULL #define L_BITMAP_MEMORY_SET(type, pBitmap, name) \ name##_pin = ((pBitmap)->Addr.Windows.pData); \ name = name##_pin #define L_BITMAP_MEMORY_FREE(name) #define L_IMAGEPROCESSINIT(pBitmap, pProcData, type) L_ImageProcessInit(pBitmap, &pProcData, type) #define L_IMAGEPROCESSALLOCSCAN(pProcData, ptr) ptr = L_ImageProcessAllocScan(pProcData) #define L_IMAGEPROCESSALLOCCLIPSCANDATA(pProcData, p) p = L_ImageProcessAllocClipScanData(pProcData) #define L_KEEPALIVE(p) #define L_GCHANDLE_DECLARE(name) #define L_GCHANDLE_SET(name, p) #define L_GCHANDLE_DECLARE_SET(p, name) #define L_GCHANDLE_FREE(name) #define STRUCT_PTR_NAME(p) p##_ptr #define STRUCT_NAME(p) p##_struct #define L_PIN_ARRAY(p) (p != 0) ? &p[0] : 0 #define L_PIN_BUFFER(p) p #define L_PIN_DECLARE(type, p) type L__PIN* PIN(p) = NULL #define L_PIN_SET(type, p) PIN(p) = L_PIN_ARRAY(p) #define L_PIN_DECLARE_NAME(type, name) type L__PIN* name = NULL #define L_PIN_DECLARE_SET(type, p) type L__PIN* PIN(p) = L_PIN_ARRAY(p) #define L_PIN_SET_NAME(type, p, name) name = (p != 0) ? &p[0] : 0 #define L_PIN_DECLARE_SET_NAME(type, p, name) type L__PIN* name = L_PIN_ARRAY(p) #define L_PIN_FREE(p) #define L_PIN_REPIN_NAME(p, name) name = L_PIN_ARRAY(p) #define MKGC(p) p #define L_PIN_NOGC_DECLARE L_PIN_DECLARE #define L_PIN_NOGC_SET L_PIN_SET #define L_PIN_NOGC_DECLARE_SET L_PIN_DECLARE_SET #define L_PIN_NOGC_FREE L_PIN_FREE #define L_PIN_NOGC_DECLARE_NAME L_PIN_DECLARE_NAME #define L_PIN_NOGC_SET_NAME L_PIN_SET_NAME #define L_PIN_NOGC_DECLARE_SET_NAME L_PIN_DECLARE_SET_NAME #define L_DECLAREBUFFER(type, p) type *p #define L_ALLOCBUFFER(type, p, count) p = (type *)FARALLOC(count, sizeof(type)) #define L_ALLOCBUFFERINIT(type, p, count) p = (type *)FARALLOCINIT(count, sizeof(type)) #define L_FREEBUFFER(p) FARFREE(p) #define L_FREEBUFFER_CHECK(p) if(p) FARFREE(p) //// start new .NET defines // data types typedef L_HANDLE L_HANDLE_OBJECT; // General #define L_SIZEOF_STRUCT(p) sizeof(p) #define L_SIZEOFBITMAPHANDLE sizeof(BITMAPHANDLE) // Callbacks into a managed function #define L_DEFINE_DELEGATE(type, name) typedef type (pEXT_CALLBACK name) #define L_DEFINE_PUBLIC_DELEGATE L_DEFINE_DELEGATE #define L_START_CALLBACKS_CLASS(name) #define L_CALLBACK_CLASS_FUNCTION(type, name) type L_EXPORT EXT_CALLBACK name #define L_END_CALLBACKS_CLASS #define L_GET_STATIC_DELEGATE(className, type, func) func #define L_CALLBACK_CLASS_FUNCTION_IMPL(className, type, func) type L_EXPORT EXT_CALLBACK func #define L_STRUCT_ARRAY_PTR(type, name) type L_FAR* name // Calling a KernelCodecs* function #define L_KERNEL_CODECS_PARAM #define L_KERNEL_CODECS_PARAM_VALUE #define L_KERNEL_CODECS_ONE_PARAM #define L_KERNEL_CODECS_ONE_PARAM_VALUE #define L_KERNEL_CODECS_FUNC(p) p // general macros #define L_DELEGATE_PTR(p) p #define L_INVOKE_DELEGATE(p) p #define L_NEW_STRUCT_PTR(type, p) type p##_struct; type* p = &p##_struct #define L_NEW_ARRAY(type, p, count) type p[count]; #define L_ZERO_STRUCT(p, s) FMEMSET(p, 0, s) #define L_COPY_STRUCT(dest, src, type) memcpy(dest, src, sizeof(type)) #define L_DYNAMIC_CAST(t, p) (t)(p) #define L_DEREF_INTPTR(type, p) (type)(p) #define L_FARALLOC_OBJECT(type) (type L_FAR*)FARALLOC(sizeof(type), 1) #define L_FARFREE_OBJECT FARFREE #define L_STRING_SIZE(name, size) L_TCHAR name[size] #define L_STRING_CLASS(name, str, ptr) L_TCHAR L_FAR* ptr = str //// end new .NET defines #undef _HEADER_ENTRY_ #include "ltpck.h" #endif // #if !defined(FOR_DOTNET) #endif /* _LTTYP_H_ */