Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

csprof.h File Reference

#include "windows.h"
#include "icc.h"
#include "icc_i386.h"

Go to the source code of this file.

Defines

#define TYPE_CIEBASEDDEF   1
#define TYPE_CIEBASEDDEFG   2
#define TempBfSize   128
#define CIEXYZRange   1.99997
#define MAX_LINELENG   240

Typedefs

typedef MEMPTR CHANDLE
typedef MEMPTR __far * LPCHANDLE

Functions

BOOL EXTERN LoadCP (LPCSTR filename, HGLOBAL FAR *phMem, LPCHANDLE lphCP)
BOOL EXTERN LoadCP32 (LPCSTR filename, HGLOBAL *phMem, LPCHANDLE lpCP)
BOOL EXTERN FreeCP (HGLOBAL hMem)
BOOL EXTERN ValidateCP (CHANDLE hCP)
BOOL EXTERN DoesCPTagExist (CHANDLE hCP, CSIG CPTag)
BOOL EXTERN GetCPTagIndex (CHANDLE hCP, CSIG CPTag, LPSINT lpIndex)
BOOL EXTERN GetCPElementCount (CHANDLE hCP, LPSINT lpIndex)
BOOL EXTERN ValidateCPElement (CHANDLE hCP, SINT Index)
BOOL EXTERN GetCPTagSig (CHANDLE hCP, SINT Index, LPCSIG lpCPTag)
BOOL EXTERN GetCPElementType (CHANDLE hCP, SINT Index, LPCSIG lpCSig)
BOOL EXTERN GetCPElementSize (CHANDLE hCP, SINT Index, LPSINT lpSize)
BOOL EXTERN GetCPElementDataSize (CHANDLE hCP, SINT Index, LPSINT lpSize)
BOOL EXTERN GetCPElement (CHANDLE hCP, SINT Index, MEMPTR lpData, SINT Size)
BOOL EXTERN GetCPElementData (CHANDLE hCP, SINT Index, MEMPTR lpData, SINT Size)
BOOL EXTERN GetCPElementDataType (CHANDLE CP, SINT Index, long far *lpDataType)
BOOL EXTERN GetCPSize (CHANDLE hCP, LPSINT lpSize)
BOOL EXTERN GetCPCMMType (CHANDLE hCP, LPCSIG lpType)
BOOL EXTERN GetCPVersion (CHANDLE hCP, LPSINT lpVers)
BOOL EXTERN GetCPClass (CHANDLE hCP, LPCSIG lpClass)
BOOL EXTERN GetCPDevSpace (CHANDLE hCP, LPCSIG lpDevSpace)
BOOL EXTERN GetCPConnSpace (CHANDLE hCP, LPCSIG lpConnSpace)
BOOL EXTERN GetCPTarget (CHANDLE hCP, LPCSIG lpTarget)
BOOL EXTERN GetCPManufacturer (CHANDLE hCP, LPCSIG lpManuf)
BOOL EXTERN GetCPModel (CHANDLE hCP, LPCSIG lpModel)
BOOL EXTERN GetCPFlags (CHANDLE hCP, LPSINT lpFlags)
BOOL EXTERN GetCPAttributes (CHANDLE hCP, LPATTRIB lpAttributes)
BOOL EXTERN GetCPWhitePoint (CHANDLE CP, LPSFLOAT lpWP)
BOOL EXTERN GetCPMediaWhitePoint (CHANDLE CP, LPSFLOAT lpMediaWP)
BOOL EXTERN GetCPRenderIntent (CHANDLE CP, LPSINT lpIntent)
BOOL EXTERN GetPS2ColorRenderingIntent (CHANDLE cp, DWORD Intent, MEMPTR lpMem, LPDWORD Size)
SINT EXTERN GetCPLastCPError ()
BOOL EXTERN SetCPLastCPError (SINT cpError)
BOOL EXTERN SetCPLastError (SINT LastError)
BOOL EXTERN ValidColorSpace (LPPDEVICE lppd, LPICMINFO lpICMI)
SINT WriteInt (MEMPTR lpMem, SINT Number)
SINT WriteHex (MEMPTR lpMem, SINT Number)
SINT WriteObject (MEMPTR lpMem, MEMPTR Obj)
SINT WriteObjectN (MEMPTR lpMem, MEMPTR Obj, SINT n)
SINT WriteHexBuffer (MEMPTR lpMem, MEMPTR lpBuff, MEMPTR lpLineStart, DWORD dwBytes)
SINT WriteFloat (MEMPTR lpMem, double dFloat)
SINT WriteStringToken (MEMPTR lpMem, BYTE Token, SINT sNum)
SINT WriteByteString (MEMPTR lpMem, MEMPTR lpBuff, SINT sBytes)
SINT WriteInt2ByteString (MEMPTR lpMem, MEMPTR lpBuff, SINT sBytes)
SINT WriteIntStringU2S (MEMPTR lpMem, MEMPTR lpBuff, SINT sNum)
SINT WriteIntStringU2S_L (MEMPTR lpMem, MEMPTR lpBuff, SINT sNum)
SINT WriteHNAToken (MEMPTR lpMem, BYTE Token, SINT sNum)
SINT WriteAscii85 (MEMPTR lpDest, unsigned long inword, SINT nBytes)
SINT ConvertBinaryData2Ascii (MEMPTR lpMem, SINT DataSize, SINT BufSize)
SINT Convert2Ascii (CHANDLE CP, SINT Index, MEMPTR lpData, SINT BufSize, SINT DataSize, BOOL AllowBinary)
BOOL EXTERN MemAlloc (SINT Size, HGLOBAL FAR *hMemory, LPMEMPTR lpMH)
BOOL EXTERN MemFree (HGLOBAL hMem)
DWORD FIXED_2DOT30 (float)
DWORD FIXED_16DOT16 (float)

Define Documentation

#define CIEXYZRange   1.99997
 

Definition at line 15 of file dec97/dll32/csprof.h.

#define MAX_LINELENG   240
 

Definition at line 16 of file dec97/dll32/csprof.h.

#define TempBfSize   128
 

Definition at line 14 of file dec97/dll32/csprof.h.

#define TYPE_CIEBASEDDEF   1
 

Definition at line 12 of file dec97/dll32/csprof.h.

#define TYPE_CIEBASEDDEFG   2
 

Definition at line 13 of file dec97/dll32/csprof.h.

Typedef Documentation

typedef MEMPTR CHANDLE
 

Definition at line 39 of file dec97/dll32/csprof.h.

typedef MEMPTR __far* LPCHANDLE
 

Definition at line 39 of file dec97/dll32/csprof.h.

Function Documentation

SINT Convert2Ascii (  CHANDLE  CP,
SINT  Index,
MEMPTR  lpData,
SINT  BufSize,
SINT  DataSize,
BOOL  AllowBinary
) 
 

Definition at line 1485 of file aug98/dll32/csprof.c. 

01488 {
01489     long    DataType;
01490 
01491     GetCPElementDataType(CP, Index, &DataType);
01492     if (BufSize == 0)
01493     {
01494         if (AllowBinary)
01495             return (DataSize);
01496         else if (DataType == 0)    // Ascii data in Profile 
01497             return (DataSize);
01498         else                       // Keep space for ascii85 encoding.
01499             return (DataSize / 4 * 5 + sizeof(ASCII85DecodeBegine)+sizeof(ASCII85DecodeEnd) + 2048);
01500     }
01501     else
01502     {
01503         if (AllowBinary)
01504             return (DataSize);
01505         else if(DataType == 0) 
01506             return (DataSize);
01507         else 
01508             return (ConvertBinaryData2Ascii(lpData, DataSize, BufSize) );
01509     }
01510 }

SINT ConvertBinaryData2Ascii (  MEMPTR  lpMem,
SINT  DataSize,
SINT  BufSize
) 
 

Definition at line 1440 of file aug98/dll32/csprof.c. 

01441 {
01442     MEMPTR      intrbuf, Temp;
01443     HANDLE      intrhandle;
01444     SINT        AsciiDataSize = 0;
01445 
01446     if (BufSize >= (SINT)(DataSize/4*5 + sizeof(ASCII85DecodeBegine)+sizeof(ASCII85DecodeEnd) + 2048))
01447     {
01448         if ((intrhandle = GlobalAlloc(GHND, BufSize)) != NULL)
01449         {
01450             if ((intrbuf = (MEMPTR) GlobalLock(intrhandle)) != NULL)
01451             {
01452                 Temp = intrbuf;
01453                 Temp += WriteObject(Temp,  NewLine);
01454                 Temp += WriteObject(Temp,  ASCII85DecodeBegine);
01455                 Temp += WriteObject(Temp,  NewLine);
01456                 Temp += WriteASCII85Cont(Temp, BufSize, lpMem, DataSize);
01457                 Temp += WriteObject(Temp,  ASCII85DecodeEnd);
01458                 AsciiDataSize = (SINT)(Temp - intrbuf);
01459                 lstrcpyn(lpMem, intrbuf, (WORD)AsciiDataSize); 
01460                 GlobalUnlock(intrhandle);
01461             }
01462         }
01463         GlobalFree(intrhandle);
01464    }
01465    return (AsciiDataSize);
01466 }

BOOL EXTERN DoesCPTagExist (  CHANDLE  hCP,
CSIG  CPTag
) 
 

Definition at line 403 of file aug98/dll32/csprof.c. 

00404 {
00405     SINT    Count;
00406     MEMPTR   Data;
00407     lpcpTagList lpTL;
00408 
00409     lpTL = (lpcpTagList) &(((lpcpProfile)CP)->count);
00410     Count   = ui32toSINT(lpTL->count);
00411     Data    = (MEMPTR)  &(lpTL->tags[0]) ; 
00412     while ( Count-- )
00413     {
00414         if(  SigtoCSIG( ((lpcpTag)Data)->sig) == CPTag )
00415         {
00416             return(TRUE);
00417         }else
00418         {
00419             Data    += sizeof(icTag);   // Bump pointer to the next tag
00420         }
00421     }
00422     return(FALSE);
00423 }

DWORD FIXED_16DOT16 (  float   ) 
 

DWORD FIXED_2DOT30 (  float   ) 
 

BOOL EXTERN FreeCP (  HGLOBAL  hMem  ) 
 

Definition at line 212 of file aug98/dll32/csprof.c. 

00213 {
00214     return( MemFree(hMem) );
00215 }

BOOL EXTERN GetCPAttributes (  CHANDLE  hCP,
LPATTRIB  lpAttributes
) 
 

Definition at line 885 of file aug98/dll32/csprof.c. 

00886 {
00887     return(TRUE);
00888 }

BOOL EXTERN GetCPClass (  CHANDLE  hCP,
LPCSIG  lpClass
) 
 

Definition at line 784 of file aug98/dll32/csprof.c. 

00785 {
00786     if (lpClass == NULL)
00787     {
00788         SetCPLastError(CP_NULL_POINTER_ERR);
00789         return(FALSE);
00790     }
00791     *lpClass    = SigtoCSIG( ((lpcpHeader)CP)->deviceClass);
00792     return(TRUE);
00793 }

BOOL EXTERN GetCPCMMType (  CHANDLE  hCP,
LPCSIG  lpType
) 
 

Definition at line 762 of file aug98/dll32/csprof.c. 

00763 {
00764     if (lpType == NULL)
00765     {
00766         SetCPLastError(CP_NULL_POINTER_ERR);
00767         return(FALSE);
00768     }
00769     *lpType    = SigtoCSIG( ((lpcpHeader)CP)->cmmId);
00770     return(TRUE);
00771 }

BOOL EXTERN GetCPConnSpace (  CHANDLE  hCP,
LPCSIG  lpConnSpace
) 
 

Definition at line 806 of file aug98/dll32/csprof.c. 

00807 {
00808     if (lpOutSpace == NULL)
00809     {
00810         SetCPLastError(CP_NULL_POINTER_ERR);
00811         return(FALSE);
00812     }
00813     *lpOutSpace    = SigtoCSIG( ((lpcpHeader)CP)->pcs);
00814     return(TRUE);
00815 }

BOOL EXTERN GetCPDevSpace (  CHANDLE  hCP,
LPCSIG  lpDevSpace
) 
 

Definition at line 795 of file aug98/dll32/csprof.c. 

00796 {
00797     if (lpInSpace == NULL)
00798     {
00799         SetCPLastError(CP_NULL_POINTER_ERR);
00800         return(FALSE);
00801     }
00802     *lpInSpace    = SigtoCSIG( ((lpcpHeader)CP)->colorSpace);
00803     return(TRUE);
00804 }

BOOL EXTERN GetCPElement (  CHANDLE  hCP,
SINT  Index,
MEMPTR  lpData,
SINT  Size
) 
 

Definition at line 557 of file aug98/dll32/csprof.c. 

00559 {
00560     SINT        ElemSize;
00561     MEMPTR      TagData, ElemData;
00562     if (lpData == NULL)
00563     {
00564         SetCPLastError(CP_NULL_POINTER_ERR);
00565         return(FALSE);
00566     }
00567 
00568     if ( !GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00569             (LPMEMPTR) &ElemData) )
00570     {
00571         return(FALSE);
00572     }
00573     ElemSize    = ui32toSINT( ((lpcpTag)TagData)->size);
00574     if(ElemSize > Size )
00575     {
00576         SetCPLastError(CP_NO_MEMORY_ERR);
00577         return(FALSE);
00578     }
00579     MemCopy(lpData, ElemData, ElemSize);
00580     return(TRUE);
00581 
00582 }

BOOL EXTERN GetCPElementCount (  CHANDLE  hCP,
LPSINT  lpIndex
) 
 

Definition at line 218 of file aug98/dll32/csprof.c. 

00219 {
00220     lpcpTagList lpTL;
00221     if (lpCount == NULL)
00222     {
00223         SetCPLastError(CP_NULL_POINTER_ERR);
00224         return(FALSE);
00225     }
00226     lpTL = (lpcpTagList) &(((lpcpProfile)CP)->count);
00227     *lpCount = ui32toSINT(lpTL->count);
00228     return(TRUE);
00229 }

BOOL EXTERN GetCPElementData (  CHANDLE  hCP,
SINT  Index,
MEMPTR  lpData,
SINT  Size
) 
 

Definition at line 585 of file aug98/dll32/csprof.c. 

00587 {
00588     SINT     ElemSize;
00589     MEMPTR   TagData, ElemData;
00590     if (lpData == NULL)
00591     {
00592         SetCPLastError(CP_NULL_POINTER_ERR);
00593         return(FALSE);
00594     }
00595 
00596     if ( !GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00597             (LPMEMPTR) &ElemData) )
00598     {
00599         return(FALSE);
00600     }
00601 //  Changed by jjia 8/24/95
00602 //    ElemData    +=  sizeof(lpcpTagBase);
00603 //    ElemSize    = ui32toSINT( ((lpcpTag)TagData)->size) - 
00604 //                     sizeof(lpcpTagBase);
00605     ElemData    +=  sizeof(icTagBase) + sizeof(icUInt32Number);
00606     ElemSize    = ui32toSINT( ((lpcpTag)TagData)->size) - 
00607                     sizeof(icTagBase) - sizeof(icUInt32Number);
00608 
00609     if(ElemSize > Size )
00610     {
00611         SetCPLastError(CP_NO_MEMORY_ERR);
00612         return(FALSE);
00613     }
00614 
00615     MemCopy(lpData, ElemData, ElemSize);
00616     return(TRUE);
00617 }

BOOL EXTERN GetCPElementDataSize (  CHANDLE  hCP,
SINT  Index,
LPSINT  lpSize
) 
 

Definition at line 522 of file aug98/dll32/csprof.c. 

00523 {
00524     MEMPTR  TagData, ElemData;
00525     if (lpSize == NULL)
00526     {
00527         SetCPLastError(CP_NULL_POINTER_ERR);
00528         return(FALSE);
00529     }
00530 
00531     if ( GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00532             (LPMEMPTR) &ElemData) )
00533     {
00534 //  Changed by jjia 8/24/95
00535 //        *lpSize     = ui32toSINT( ((lpcpTag)TagData)->size ) -
00536 //                                             sizeof(lpcpTagBase);
00537     *lpSize    = ui32toSINT( ((lpcpTag)TagData)->size) - 
00538                     sizeof(icTagBase) - sizeof(icUInt32Number);
00539     }else
00540     {
00541         return(FALSE);
00542     }
00543 
00544     return(TRUE);
00545 }

BOOL EXTERN GetCPElementDataType (  CHANDLE  CP,
SINT  Index,
long far *  lpDataType
) 
 

Definition at line 621 of file aug98/dll32/csprof.c. 

00622 {
00623     MEMPTR   TagData, ElemData;
00624 
00625     if (lpDataType == NULL)
00626     {
00627         SetCPLastError(CP_NULL_POINTER_ERR);
00628         return(FALSE);
00629     }
00630 
00631     if ( !GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00632             (LPMEMPTR) &ElemData) )
00633     {
00634         return(FALSE);
00635     }
00636     ElemData    +=  sizeof(icTagBase);
00637     *lpDataType = ui32toSINT( ((icData __huge *)ElemData)->dataFlag);
00638     return (TRUE);
00639 }

BOOL EXTERN GetCPElementSize (  CHANDLE  hCP,
SINT  Index,
LPSINT  lpSize
) 
 

Definition at line 501 of file aug98/dll32/csprof.c. 

00502 {
00503     MEMPTR   TagData, ElemData;
00504     if (lpSize == NULL)
00505     {
00506         SetCPLastError(CP_NULL_POINTER_ERR);
00507         return(FALSE);
00508     }
00509 
00510     if ( GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00511             (LPMEMPTR) &ElemData) )
00512     {
00513         *lpSize     = ui32toSINT( ((lpcpTag)TagData)->size );
00514     }else
00515     {
00516         return(FALSE);
00517     }
00518 
00519     return(TRUE);
00520 }

BOOL EXTERN GetCPElementType (  CHANDLE  hCP,
SINT  Index,
LPCSIG  lpCSig
) 
 

Definition at line 485 of file aug98/dll32/csprof.c. 

00486 {
00487     MEMPTR   TagData, ElemData;
00488     if ( GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00489             (LPMEMPTR) &ElemData) )
00490     {
00491         *lpCSig    = SigtoCSIG( ((lpcpTagBase)ElemData)->sig ) ;
00492     }else
00493     {
00494         return(FALSE);
00495     }
00496     return(TRUE);
00497 }

BOOL EXTERN GetCPFlags (  CHANDLE  hCP,
LPSINT  lpFlags
) 
 

Definition at line 850 of file aug98/dll32/csprof.c. 

00851 {
00852     if (lpFlags == NULL)
00853     {
00854         SetCPLastError(CP_NULL_POINTER_ERR);
00855         return(FALSE);
00856     }
00857     *lpFlags    = ui32toSINT( ((lpcpHeader)CP)->flags);
00858     return(TRUE);
00859 }

SINT EXTERN GetCPLastCPError (   ) 
 

BOOL EXTERN GetCPManufacturer (  CHANDLE  hCP,
LPCSIG  lpManuf
) 
 

Definition at line 828 of file aug98/dll32/csprof.c. 

00829 {
00830     if (lpManuf == NULL)
00831     {
00832         SetCPLastError(CP_NULL_POINTER_ERR);
00833         return(FALSE);
00834     }
00835     *lpManuf    = SigtoCSIG( ((lpcpHeader)CP)->manufacturer);
00836     return(TRUE);
00837 }

BOOL EXTERN GetCPMediaWhitePoint (  CHANDLE  CP,
LPSFLOAT  lpMediaWP
) 
 

Definition at line 890 of file aug98/dll32/csprof.c. 

00891 {
00892     HGLOBAL   hTempMem;
00893     SINT      TempSize;
00894     MEMPTR    TempBuff;
00895     MEMPTR    lpTable;
00896     SINT      i, Index;
00897 
00898     if (DoesCPTagExist (cp, icSigMediaWhitePointTag) &&
00899         GetCPTagIndex (cp, icSigMediaWhitePointTag, (LPSINT) & Index) &&
00900         GetCPElementSize (cp, Index, (LPSINT) & TempSize) &&
00901         MemAlloc (TempSize, (HGLOBAL *) & hTempMem, (LPMEMPTR) & TempBuff) &&
00902         GetCPElement (cp, Index, TempBuff, TempSize))
00903     {
00904         lpTable = (MEMPTR) & (((lpcpXYZType) TempBuff)->data);
00905         for (i = 0; i < 3; i++)
00906         {
00907             lpMediaWP[i] = (SFLOAT) si16f16toSFLOAT (lpTable);
00908             lpTable += sizeof (icS15Fixed16Number);
00909         }
00910         MemFree (hTempMem);
00911         return (TRUE);
00912     }
00913     return (FALSE);
00914 }

BOOL EXTERN GetCPModel (  CHANDLE  hCP,
LPCSIG  lpModel
) 
 

Definition at line 839 of file aug98/dll32/csprof.c. 

00840 {
00841     if (lpModel == NULL)
00842     {
00843         SetCPLastError(CP_NULL_POINTER_ERR);
00844         return(FALSE);
00845     }
00846     *lpModel    = SigtoCSIG( ((lpcpHeader)CP)->model);
00847     return(TRUE);
00848 }

BOOL EXTERN GetCPRenderIntent (  CHANDLE  CP,
LPSINT  lpIntent
) 
 

Definition at line 861 of file aug98/dll32/csprof.c. 

00862 {
00863     if (lpIntent == NULL)
00864     {
00865         SetCPLastError(CP_NULL_POINTER_ERR);
00866         return(FALSE);
00867     }
00868     *lpIntent    = ui32toSINT( ((lpcpHeader)CP)->renderingIntent);
00869     return(TRUE);
00870 }

BOOL EXTERN GetCPSize (  CHANDLE  hCP,
LPSINT  lpSize
) 
 

Definition at line 751 of file aug98/dll32/csprof.c. 

00752 {
00753     if (lpSize == NULL)
00754     {
00755         SetCPLastError(CP_NULL_POINTER_ERR);
00756         return(FALSE);
00757     }
00758     *lpSize    = ui32toSINT( ((lpcpHeader)CP)->size);
00759     return(TRUE);
00760 }

BOOL EXTERN GetCPTagIndex (  CHANDLE  hCP,
CSIG  CPTag,
LPSINT  lpIndex
) 
 

Definition at line 426 of file aug98/dll32/csprof.c. 

00427 {
00428     SINT    Count;
00429     MEMPTR   Data;
00430     SINT    i;
00431     lpcpTagList lpTL;
00432 
00433     if (lpIndex == NULL)
00434     {
00435         SetCPLastError(CP_NULL_POINTER_ERR);
00436         return(FALSE);
00437     }
00438 
00439     lpTL = (lpcpTagList) &(((lpcpProfile)CP)->count);
00440     Count   = ui32toSINT(lpTL->count);
00441     Data    = (MEMPTR)  &(lpTL->tags[0]) ;
00442 
00443     for (i = 0; i < Count; i++ )
00444     {
00445         if(  SigtoCSIG( ((lpcpTag)Data)->sig) == CPTag )
00446         {
00447             *lpIndex = i;
00448             return(TRUE);
00449         }else
00450         {
00451             Data    += sizeof(icTag);   // Bump pointer to the next tag
00452         }
00453     }
00454 
00455     SetCPLastError(CP_NOT_FOUND_ERR);
00456     return(FALSE);
00457 }

BOOL EXTERN GetCPTagSig (  CHANDLE  hCP,
SINT  Index,
LPCSIG  lpCPTag
) 
 

Definition at line 461 of file aug98/dll32/csprof.c. 

00462 {
00463     MEMPTR   TagData, ElemData;
00464     if (lpCPTag == NULL)
00465     {
00466         SetCPLastError(CP_NULL_POINTER_ERR);
00467         return(FALSE);
00468     }
00469     if ( GetCPElementInfo(CP, Index, (LPMEMPTR) &TagData,
00470             (LPMEMPTR) &ElemData) )
00471     {
00472         *lpCPTag    = SigtoCSIG( ((lpcpTag)TagData)->sig ) ;
00473     }else
00474     {
00475         return(FALSE);
00476     }
00477     return(TRUE);
00478 }

BOOL EXTERN GetCPTarget (  CHANDLE  hCP,
LPCSIG  lpTarget
) 
 

Definition at line 817 of file aug98/dll32/csprof.c. 

00818 {
00819     if (lpTarget == NULL)
00820     {
00821         SetCPLastError(CP_NULL_POINTER_ERR);
00822         return(FALSE);
00823     }
00824     *lpTarget    = SigtoCSIG( ((lpcpHeader)CP)->platform);
00825     return(TRUE);
00826 }

BOOL EXTERN GetCPVersion (  CHANDLE  hCP,
LPSINT  lpVers
) 
 

Definition at line 773 of file aug98/dll32/csprof.c. 

00774 {
00775     if (lpVers == NULL)
00776     {
00777         SetCPLastError(CP_NULL_POINTER_ERR);
00778         return(FALSE);
00779     }
00780     *lpVers    = ui32toSINT( ((lpcpHeader)CP)->version);
00781     return(TRUE);
00782 }

BOOL EXTERN GetCPWhitePoint (  CHANDLE  CP,
LPSFLOAT  lpWP
) 
 

Definition at line 872 of file aug98/dll32/csprof.c. 

00873 {
00874     if (lpWP == NULL)
00875     {
00876         SetCPLastError(CP_NULL_POINTER_ERR);
00877         return(FALSE);
00878     }
00879     lpWP[0]    = (SFLOAT) si16f16toSFLOAT( ((lpcpHeader)CP)->illuminant.X);
00880     lpWP[1]    = (SFLOAT) si16f16toSFLOAT( ((lpcpHeader)CP)->illuminant.Y);
00881     lpWP[2]    = (SFLOAT) si16f16toSFLOAT( ((lpcpHeader)CP)->illuminant.Z);
00882     return(TRUE);
00883 }

BOOL EXTERN GetPS2ColorRenderingIntent (  CHANDLE  cp,
DWORD  Intent,
MEMPTR  lpMem,
LPDWORD  Size
) 
 

Definition at line 938 of file aug98/dll32/csprof.c. 

00940 {
00941     SINT       Index;
00942     SINT       Size;
00943         
00944     if (!cp)
00945         return FALSE;
00946 
00947     Size = (SINT) *lpcbSize;
00948     if( ( lpMem == NULL ) || ( Size == 0 ) )
00949     {
00950         lpMem = NULL;
00951         Size = 0;
00952         *lpcbSize = 0;
00953     }
00954         
00955     switch(Intent)
00956     {
00957         case icPerceptual:
00958         if( DoesCPTagExist(cp, icSigPs2Intent0Tag) &&
00959             GetCPTagIndex(cp, icSigPs2Intent0Tag, (LPSINT) &Index) &&
00960             GetCPElementDataSize(cp, Index, (LPSINT) &Size) &&
00961             ( ( lpMem == NULL ) ||
00962                 GetCPElementData(cp, Index, lpMem, Size) ) )
00963         {
00964         }
00965         break;
00966         
00967         case icRelativeColorimetric:
00968         if( DoesCPTagExist(cp, icSigPs2Intent1Tag) &&
00969             GetCPTagIndex(cp, icSigPs2Intent1Tag, (LPSINT) &Index) &&
00970             GetCPElementDataSize(cp, Index, (LPSINT) &Size) &&
00971             ( ( lpMem == NULL ) ||
00972                 GetCPElementData(cp, Index, lpMem, Size) ) )
00973         {
00974         }
00975         break;
00976     
00977         case icSaturation:
00978         if( DoesCPTagExist(cp, icSigPs2Intent2Tag) &&
00979             GetCPTagIndex(cp, icSigPs2Intent2Tag, (LPSINT) &Index) &&
00980             GetCPElementDataSize(cp, Index, (LPSINT) &Size) &&
00981             ( ( lpMem == NULL ) ||
00982                 GetCPElementData(cp, Index, lpMem, Size ) )
00983           )
00984         {
00985         }
00986         break;
00987         case icAbsoluteColorimetric:
00988         if( DoesCPTagExist(cp, icSigPs2Intent3Tag) &&
00989             GetCPTagIndex(cp, icSigPs2Intent3Tag, (LPSINT) &Index) &&
00990             GetCPElementDataSize(cp, Index, (LPSINT) &Size) &&
00991             ( ( lpMem == NULL ) ||
00992                 GetCPElementData(cp, Index, lpMem, Size) ) )
00993         {
00994         }
00995         break;
00996         default:
00997             Size = 0 ;
00998         break;
00999     }
01000         
01001     if (Size != 0)
01002     {
01003         if (lpMem)
01004         {
01005             lpMem[Size] = '\0';
01006         }
01007         Size ++;
01008         *lpcbSize = (DWORD) Size;
01009         return (TRUE);
01010     }
01011     else
01012     {
01013         return(FALSE);
01014     }
01015 }

BOOL EXTERN LoadCP (  LPCSTR  filename,
HGLOBAL FAR *  phMem,
LPCHANDLE  lphCP
) 
 

Definition at line 80 of file aug98/dll32/csprof.c. 

00081 {
00082     icHeader    CPHeader;
00083     HFILE       hFile;
00084     SINT        Res, CPSize;
00085     MEMPTR      mpCP;
00086 
00087     *phMem = 0;
00088     if (lpCP == NULL)
00089     {
00090         SetCPLastError(CP_NULL_POINTER_ERR);
00091         return(FALSE);
00092     }
00093 
00094     hFile = _lopen(filename, READ );
00095     if( hFile == HFILE_ERROR )
00096     {
00097         SetCPLastError(CP_FILE_OPEN_ERR);
00098         return(FALSE);
00099     }
00100  
00101     Res = _lread(hFile, (LPVOID) &CPHeader, sizeof(CPHeader));
00102     if( (Res == HFILE_ERROR) ||
00103         (Res != sizeof(CPHeader)) )
00104     {
00105         _lclose(hFile);
00106         SetCPLastError(CP_FILE_READ_ERR);
00107         return(FALSE);
00108     }
00109 
00110     // Make the initial check for validity of the profile
00111     if( SigtoCSIG(CPHeader.magic) != icMagicNumber )
00112     {
00113         _lclose(hFile);
00114         SetCPLastError(CP_FORMAT_ERR);
00115         return(FALSE);
00116     }
00117 
00118     CPSize = ui32toSINT(CPHeader.size);
00119     if( MemAlloc(CPSize, phMem, (LPMEMPTR) &mpCP) )
00120     {
00121 
00122         *lpCP = (CHANDLE) mpCP;  // Put the memory pointer as  handle
00123         // Read profile into  memory
00124          _lseek(hFile, 0L, SEEK_SET);
00125 
00126         while(CPSize)
00127         {
00128             Res = _lread(hFile, (LPVOID) mpCP, 4096);
00129             if (Res == HFILE_ERROR) 
00130             {
00131                 _lclose(hFile);
00132                 SetCPLastError(CP_FILE_READ_ERR);
00133                 return(FALSE);
00134             }
00135             mpCP    += Res;
00136             CPSize  -= Res;
00137         }
00138     }else
00139     {
00140         *phMem = 0;
00141         _lclose(hFile);
00142         return(FALSE);
00143     }
00144     _lclose(hFile);
00145     return (TRUE);
00146 }

BOOL EXTERN LoadCP32 (  LPCSTR  filename,
HGLOBAL *  phMem,
LPCHANDLE  lpCP
) 
 

BOOL EXTERN MemAlloc (  SINT  Size,
HGLOBAL FAR *  hMemory,
LPMEMPTR  lpMH
) 
 

Definition at line 32 of file aug98/dll32/csprof.c. 

00033 {
00034     HGLOBAL hMem;
00035     LPVOID  lpMem;
00036 
00037     *hMemory = 0;
00038     if(lpMH == NULL )
00039     {
00040         SetCPLastError(CP_NULL_POINTER_ERR);
00041         return(FALSE);
00042     }
00043 
00044     hMem = GlobalAlloc(GHND, Size) ;
00045     if(hMem == 0 )
00046     {
00047         SetCPLastError(CP_MEMORY_ALLOC_ERR);
00048         return(FALSE);
00049     }
00050 
00051     lpMem = GlobalLock(hMem);
00052     if(lpMem == NULL )
00053     {
00054         GlobalFree(hMem);
00055         SetCPLastError(CP_MEMORY_ALLOC_ERR);
00056         return(FALSE);
00057     }
00058     *lpMH = (MEMPTR)lpMem ;
00059     *hMemory = hMem;
00060     return (TRUE);
00061 }

BOOL EXTERN MemFree (  HGLOBAL  hMem  ) 
 

Definition at line 63 of file aug98/dll32/csprof.c. 

00064 {
00065     if(hMem == NULL )
00066     {
00067         SetCPLastError(CP_NULL_POINTER_ERR);
00068         return(FALSE);
00069     }
00070 
00071     GlobalUnlock(hMem);
00072     GlobalFree(hMem) ;
00073     return(TRUE);
00074 }

BOOL EXTERN SetCPLastCPError (  SINT  cpError  ) 
 

BOOL EXTERN SetCPLastError (  SINT  LastError  ) 
 

Definition at line 21 of file aug98/dll32/csprof.c. 

00022 {
00023     CPLastError = LastError;
00024     return(TRUE);
00025 }

BOOL EXTERN ValidateCP (  CHANDLE  hCP  ) 
 

Definition at line 260 of file aug98/dll32/csprof.c. 

00261 {
00262     BOOL    Result;
00263     CSIG    ProfileClass;
00264 
00265     if(GetCPClass(CP, (LPCSIG) &ProfileClass) )
00266     {
00267         // All profiles must have a ProfileDescription and
00268         //  a Copyright  tags.
00269 
00270         if( !DoesCPTagExist(CP, icSigProfileDescriptionTag) || 
00271             !DoesCPTagExist(CP, icSigCopyrightTag ) )
00272         {
00273             SetCPLastError(CP_NOT_FOUND_ERR);
00274             return(FALSE);
00275         }
00276 
00277         // All profiles, except Device-link, must have a mediaWhitePoint Tag
00278         switch( ProfileClass )
00279         {
00280             case     icSigLinkClass :        /* 'link' */
00281                 if( DoesCPTagExist(CP, icSigAToB0Tag) &&
00282                     DoesCPTagExist(CP, icSigProfileSequenceDescTag)
00283                   )
00284                 {
00285                     Result = TRUE;
00286                 }else
00287                 {
00288                     Result = FALSE;
00289                 }
00290                 break;
00291 
00292             case     icSigInputClass:       /* 'scnr' */
00293                 if( DoesCPTagExist(CP, icSigGrayTRCTag) ||
00294                     DoesCPTagExist(CP, icSigAToB0Tag)      )
00295                 {
00296                     Result = TRUE;
00297                 }else if( DoesCPTagExist(CP, icSigGreenColorantTag) )
00298                 {
00299                     if( DoesCPTagExist(CP, icSigRedColorantTag) &&
00300                         DoesCPTagExist(CP, icSigBlueColorantTag) &&
00301                         DoesCPTagExist(CP, icSigRedTRCTag) &&
00302                         DoesCPTagExist(CP, icSigGreenTRCTag) &&
00303                         DoesCPTagExist(CP, icSigBlueTRCTag)
00304                       )
00305                     {
00306                         Result = TRUE;
00307                     }else
00308                     {
00309                         Result = FALSE;
00310                     }
00311                 }else
00312                 {
00313                     Result = FALSE;
00314                 }
00315                 Result  &= DoesCPTagExist(CP, icSigMediaWhitePointTag);
00316                 break;
00317 
00318             case     icSigDisplayClass:     /* 'mntr' */
00319                 if( DoesCPTagExist(CP, icSigGrayTRCTag) )
00320                 {
00321                     Result = TRUE;
00322                 }else if( DoesCPTagExist(CP, icSigGreenColorantTag) )
00323                 {
00324                     if( DoesCPTagExist(CP, icSigRedColorantTag) &&
00325                         DoesCPTagExist(CP, icSigBlueColorantTag) &&
00326                         DoesCPTagExist(CP, icSigRedTRCTag) &&
00327                         DoesCPTagExist(CP, icSigGreenTRCTag) &&
00328                         DoesCPTagExist(CP, icSigBlueTRCTag)
00329                       )
00330                     {
00331                         Result = TRUE;
00332                     }else
00333                     {
00334                         Result = FALSE;
00335                     }
00336                 }else
00337                 {
00338                     Result = FALSE;
00339                 }
00340                 Result  &= DoesCPTagExist(CP, icSigMediaWhitePointTag);
00341                 break;
00342 
00343             case     icSigOutputClass:      /* 'prtr' */
00344                 if( DoesCPTagExist(CP, icSigGrayTRCTag) )
00345                 {
00346                     Result = TRUE;
00347                 }else if( DoesCPTagExist(CP, icSigAToB0Tag) &&
00348                           DoesCPTagExist(CP, icSigAToB1Tag) &&
00349                           DoesCPTagExist(CP, icSigAToB2Tag) &&
00350                           DoesCPTagExist(CP, icSigBToA0Tag) &&
00351                           DoesCPTagExist(CP, icSigBToA1Tag) &&
00352                           DoesCPTagExist(CP, icSigBToA2Tag) &&
00353                           DoesCPTagExist(CP, icSigGamutTag) 
00354                         )
00355                 {
00356                     Result = TRUE;
00357                 }else
00358                 {
00359                     Result = FALSE;
00360                 }
00361                 Result  &= DoesCPTagExist(CP, icSigMediaWhitePointTag);
00362                 break;
00363 
00364             case     icSigAbstractClass:    /* 'abst' */
00365                 if( DoesCPTagExist(CP, icSigAToB0Tag) )
00366                 {
00367                     Result = TRUE;
00368                 }else
00369                 {
00370                     Result = FALSE;
00371                 }
00372                 Result  &= DoesCPTagExist(CP, icSigMediaWhitePointTag);
00373                 break;
00374 
00375             case     icSigColorSpaceClass:  /* 'spac' */
00376                 if( DoesCPTagExist(CP, icSigAToB0Tag) &&
00377                     DoesCPTagExist(CP, icSigBToA0Tag)
00378                   )
00379                 {
00380                     Result = TRUE;
00381                 }else
00382                 {
00383                     Result = FALSE;
00384                 }
00385                 Result  &= DoesCPTagExist(CP, icSigMediaWhitePointTag);
00386                 break;
00387 
00388             default:
00389                 Result = FALSE;
00390                 break;
00391         }
00392     }else
00393     {
00394         return(FALSE);
00395     }
00396     if( Result == FALSE )
00397     {
00398         SetCPLastError(CP_NOT_FOUND_ERR);
00399     }
00400     return(Result);
00401 }

BOOL EXTERN ValidateCPElement (  CHANDLE  hCP,
SINT  Index
) 
 

Definition at line 641 of file aug98/dll32/csprof.c. 

00642 {
00643     CSIG    TagSig, DataSig;
00644     BOOL    Result;
00645     if( GetCPTagSig(CP, Index, (LPCSIG) &TagSig) &&
00646         GetCPElementType(CP, Index, (LPCSIG) &DataSig) )
00647     {
00648         switch(TagSig)
00649         {
00650             case     icSigAToB0Tag:
00651             case     icSigAToB1Tag:
00652             case     icSigAToB2Tag:
00653             case     icSigBToA0Tag:
00654             case     icSigBToA1Tag:
00655             case     icSigBToA2Tag:
00656             case     icSigGamutTag:
00657             case     icSigPreview0Tag:
00658             case     icSigPreview1Tag:
00659             case     icSigPreview2Tag:
00660                 Result = (DataSig == icSigLut16Type) ||
00661                          (DataSig == icSigLut8Type) ;
00662                 break;
00663 
00664             case     icSigRedColorantTag: 
00665             case     icSigGreenColorantTag:
00666             case     icSigBlueColorantTag:
00667             case     icSigLuminanceTag:
00668             case     icSigMediaBlackPointTag:
00669             case     icSigMediaWhitePointTag:
00670                 Result = (DataSig == icSigXYZType);
00671                 break;
00672 
00673             case     icSigRedTRCTag:
00674             case     icSigGreenTRCTag:
00675             case     icSigBlueTRCTag:
00676             case     icSigGrayTRCTag:
00677                 Result = (DataSig == icSigCurveType);
00678                 break;
00679 
00680             case     icSigPs2CRD0Tag:
00681             case     icSigPs2CRD1Tag:
00682             case     icSigPs2CRD2Tag:
00683             case     icSigPs2CRD3Tag:
00684             case     icSigPs2CSATag:
00685             case     icSigPs2Intent0Tag:
00686             case     icSigPs2Intent1Tag:
00687             case     icSigPs2Intent2Tag:
00688             case     icSigPs2Intent3Tag:
00689                 Result = (DataSig == icSigDataType);
00690                 break;
00691 
00692             case     icSigCharTargetTag:
00693             case     icSigCopyrightTag:
00694                 Result = (DataSig == icSigTextType);
00695                 break;
00696 
00697             case     icSigCalibrationDateTimeTag:
00698                 Result = (DataSig == icSigDateTimeType);
00699                 break;
00700 
00701             case     icSigDeviceMfgDescTag:
00702             case     icSigDeviceModelDescTag:
00703             case     icSigProfileDescriptionTag:
00704             case     icSigScreeningDescTag:
00705             case     icSigViewingCondDescTag:
00706                 Result = (DataSig == icSigTextDescriptionType);
00707                 break;
00708 
00709             case     icSigMeasurementTag:
00710                 Result = (DataSig == icSigMeasurementTag);
00711                 break;
00712 
00713             case     icSigNamedColorTag:
00714                 Result = (DataSig == icSigNamedColorTag);
00715                 break;
00716         
00717             case      icSigProfileSequenceDescTag:
00718                 Result = (DataSig == icSigProfileSequenceDescTag);
00719                 break;
00720 
00721             case     icSigScreeningTag:
00722                 Result = (DataSig == icSigScreeningTag);
00723                 break;
00724 
00725             case     icSigTechnologyTag:
00726                 Result = (DataSig == icSigSignatureType);
00727                 break;
00728 
00729             case     icSigUcrBgTag:
00730                 Result = (DataSig == icSigUcrBgTag);
00731                 break;
00732 
00733             case     icSigViewingConditionsTag:
00734                 Result = (DataSig == icSigViewingConditionsTag);
00735                 break;
00736 
00737             default:
00738                 Result = TRUE;
00739                 break;
00740         }
00741     }else
00742     {
00743         Result = FALSE;
00744     }
00745     return(Result);
00746 }

BOOL EXTERN ValidColorSpace (  LPPDEVICE  lppd,
LPICMINFO  lpICMI
) 
 

Definition at line 1027 of file dec97/dll32/csprof.c. 

01028 {
01029     icHeader    CPHeader;
01030     HFILE       hFile;
01031     SINT        Res;
01032     CSIG        CPColorSpaceTag;
01033 
01034     if (NULL == lpICMI)
01035     {
01036         return(FALSE);
01037     }
01038     hFile = _lopen(lpICMI->lcsDestFilename, READ);
01039     if( hFile == HFILE_ERROR )
01040     {
01041         return(FALSE);
01042     }
01043 
01044     Res = _lread(hFile, (LPVOID) &CPHeader, sizeof(CPHeader));
01045     _lclose(hFile);
01046     if( (Res == HFILE_ERROR) || (Res != sizeof(CPHeader)) )
01047     {
01048         return(FALSE);
01049     }
01050 
01051     // Make the initial check for validity of the profile
01052     if( SigtoCSIG(CPHeader.magic) != icMagicNumber )
01053     {
01054         return(FALSE);
01055     }
01056     // Make sure the profile is 'prtr'
01057     if( SigtoCSIG(CPHeader.deviceClass) != icSigOutputClass )
01058     {
01059         return(FALSE);
01060     }
01061     CPColorSpaceTag = SigtoCSIG(CPHeader.colorSpace);
01062 
01063     switch ( lppd->lpPSExtDevmode->dm.iColorMatchingMethod )
01064     {
01065         case COLOR_MATCHING_ON_HOST:
01066             if ((CPColorSpaceTag == icSigCmyData) ||
01067                 (CPColorSpaceTag == icSigRgbData))
01068 //                (CPColorSpaceTag == icSigGrayData))
01069             {
01070                 return(FALSE);
01071             }
01072             break;
01073             case COLOR_MATCHING_ON_PRINTER:
01074             if ((CPColorSpaceTag == icSigCmyData))
01075 //                (CPColorSpaceTag == icSigGrayData))
01076             {
01077                 return(FALSE);
01078             }
01079             break;
01080         case COLOR_MATCHING_PRINTER_CALIBRATION:
01081         default:
01082             break;
01083     }
01084     return (TRUE);
01085 }

SINT WriteAscii85 (  MEMPTR  lpDest,
unsigned long  inword,
SINT  nBytes
) 
 

Definition at line 1400 of file aug98/dll32/csprof.c. 

01401 {
01402     unsigned long divisor;
01403     int      bcount;
01404     BYTE     outchar;
01405     MEMPTR   lpSave = lpDest;
01406 
01407     if ((inWord == 0UL) && (nBytes == 5))
01408         *lpDest++ = 'z';
01409     else
01410     {
01411         divisor = 52200625UL;
01412         for (bcount = 0; bcount < nBytes; bcount ++)
01413         { 
01414             outchar = (BYTE)((int)(inWord/divisor) + (int)'!');
01415             *lpDest++ = outchar;
01416             if (bcount < 4)
01417             {
01418                 inWord = (inWord % divisor);
01419                 divisor =(divisor / 85);
01420             }
01421         }
01422     }
01423     return (SINT)(lpDest - lpSave);
01424 }

SINT WriteByteString (  MEMPTR  lpMem,
MEMPTR  lpBuff,
SINT  sBytes
) 
 

Definition at line 1299 of file aug98/dll32/csprof.c. 

01300 {
01301     SINT    i;
01302 
01303     for (i = 0; i < sBytes; i ++)
01304         *lpMem++ = *lpBuff++;
01305     
01306     return(sBytes); 
01307 }

SINT WriteFloat (  MEMPTR  lpMem,
double  dFloat
) 
 

Definition at line 1193 of file aug98/dll32/csprof.c. 

01194 {
01195     char    cSign;
01196     double  dInt ;
01197     double  dFract ;
01198     LONG    lFloat ;
01199     SINT    Res;
01200     char    TempArray[TempBfSize];
01201 
01202     lFloat = (LONG) floor( dFloat * 10000.0 + 0.5);
01203 
01204     dFloat = lFloat  / 10000.0 ;
01205 
01206     dInt = floor(fabs(dFloat));
01207     dFract =  fabs(dFloat) - dInt ;
01208 
01209     cSign   = ' ' ;
01210     if ( dFloat < 0 )
01211     {
01212         cSign   = '-' ;
01213     }
01214 
01215     Res = wsprintf( (LPSTR) TempArray, (LPSTR) "%c%d.%0.4lu ",
01216        cSign, (WORD) dInt , (DWORD) (dFract *10000.0)  );
01217     MemCopy(lpMem, TempArray, lstrlen(TempArray));
01218     return ( Res );
01219 }

SINT WriteHex (  MEMPTR  lpMem,
SINT  Number
) 
 

Definition at line 1177 of file aug98/dll32/csprof.c. 

01178 {
01179     SINT    Res;
01180     char    TempArray[TempBfSize];
01181 
01182     Res = wsprintf( TempArray, "%2.2x", (int)(Number & 0x00FF) );
01183     MemCopy(lpMem, TempArray, lstrlen(TempArray));
01184     return( Res );
01185 }

SINT WriteHexBuffer (  MEMPTR  lpMem,
MEMPTR  lpBuff,
MEMPTR  lpLineStart,
DWORD  dwBytes
) 
 

Definition at line 1104 of file aug98/dll32/csprof.c. 

01105 {
01106     SINT    Res;
01107     char    TempArray[TempBfSize];
01108     MEMPTR  lpOldPtr = lpMem;
01109 
01110     for ( ; dwBytes ; dwBytes-- )
01111     {
01112         Res = wsprintf( (MEMPTR)TempArray, (LPSTR) "%2.2x", *lpBuff );
01113         *lpMem++ = TempArray[0];
01114         *lpMem++ = TempArray[1];
01115         lpBuff++;
01116         if (((SINT)(lpMem - lpLineStart)) > MAX_LINELENG)
01117         {
01118             lpLineStart = lpMem;
01119             lpMem += WriteObject(lpMem,  NewLine);
01120         }
01121     }
01122     return( (SINT)(lpMem - lpOldPtr)); 
01123 }

SINT WriteHNAToken (  MEMPTR  lpMem,
BYTE  Token,
SINT  sNum
) 
 

Definition at line 1241 of file aug98/dll32/csprof.c. 

01242 {
01243     *lpMem++ = Token;
01244     *lpMem++ = 32;       // 16-bit fixed integer, high-order byte first
01245     *lpMem++ = (BYTE)((sNum & 0xFF00) >> 8);
01246     *lpMem++ = (BYTE)(sNum & 0x00FF);
01247     return (4);
01248 }

SINT WriteInt (  MEMPTR  lpMem,
SINT  Number
) 
 

Definition at line 1162 of file aug98/dll32/csprof.c. 

01163 {
01164     SINT    Res;
01165     char    TempArray[TempBfSize];
01166     
01167     Res = wsprintf( (MEMPTR)TempArray, "%lu ", Number );
01168     MemCopy(lpMem, TempArray, lstrlen(TempArray));
01169     return( Res );
01170 }

SINT WriteInt2ByteString (  MEMPTR  lpMem,
MEMPTR  lpBuff,
SINT  sBytes
) 
 

Definition at line 1314 of file aug98/dll32/csprof.c. 

01315 {
01316     SINT    i;
01317 
01318        for( i = 0; i < sBytes ; i++)
01319     {
01320         *lpMem++ = (BYTE)(ui16toSINT( lpBuff)/256) ;
01321         lpBuff += sizeof(icUInt16Number);
01322     }
01323     return(sBytes); 
01324 }

SINT WriteIntStringU2S (  MEMPTR  lpMem,
MEMPTR  lpBuff,
SINT  sNum
) 
 

Definition at line 1257 of file aug98/dll32/csprof.c. 

01258 {
01259     SINT    i;
01260     SINT    Temp;
01261 
01262     for (i = 0; i < sNum; i ++)
01263     {
01264         Temp = ui16toSINT( lpBuff) - 32768;
01265         *lpMem++ = (BYTE)((Temp & 0xFF00) >> 8);
01266         *lpMem++ = (BYTE)(Temp & 0x00FF);
01267         lpBuff += sizeof(icUInt16Number);
01268     }
01269     return(sNum * 2); 
01270 }

SINT WriteIntStringU2S_L (  MEMPTR  lpMem,
MEMPTR  lpBuff,
SINT  sNum
) 
 

Definition at line 1279 of file aug98/dll32/csprof.c. 

01280 {
01281     SINT    i;
01282     SINT    Temp;
01283 
01284     for (i = 0; i < sNum; i ++)
01285     {
01286         Temp = (SINT)*((PUSHORT)lpBuff) - 32768;
01287         *lpMem++ = (BYTE)((Temp & 0xFF00) >> 8);
01288         *lpMem++ = (BYTE)(Temp & 0x00FF);
01289         lpBuff += sizeof(icUInt16Number);
01290     }
01291     return(sNum * 2); 
01292 }

SINT WriteObject (  MEMPTR  lpMem,
MEMPTR  Obj
) 
 

Definition at line 1143 of file aug98/dll32/csprof.c. 

01144 {
01145     SINT    Res;
01146 
01147     Res = lstrlen(Obj);
01148     MemCopy(lpMem, Obj, Res);
01149     return( Res );
01150 }

SINT WriteObjectN (  MEMPTR  lpMem,
MEMPTR  Obj,
SINT  n
) 
 

Definition at line 1152 of file aug98/dll32/csprof.c. 

01153 {
01154     MemCopy(lpMem, Obj, n);
01155     return( n );
01156 }

SINT WriteStringToken (  MEMPTR  lpMem,
BYTE  Token,
SINT  sNum
) 
 

Definition at line 1227 of file aug98/dll32/csprof.c. 

01228 {
01229     *lpMem++ = Token;
01230     *lpMem++ = (BYTE)((sNum & 0xFF00) >> 8);
01231     *lpMem++ = (BYTE)(sNum & 0x00FF);
01232     return (3);
01233 }

Generated on Sat May 15 19:43:20 2004 for test by doxygen 1.3.7