Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-12-12 04:29:09 +00:00
Code Issues Projects Releases Wiki Activity
33cd9271f4
sys7.1-doc-wip/OS/VDig/ImageCompression.h
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

621 lines
26 KiB
C
Raw Blame History

/************************************************************
Created: Tuesday, August 13, 1991 at 4:25 PM
ImageCompression.h
C Interface to the Macintosh Libraries
Copyright Apple Computer, Inc. 1991
All rights reserved
************************************************************/
#ifndef __IMAGECOMPRESSION__
#define __IMAGECOMPRESSION__
#ifndef __QUICKDRAW__
#include <QuickDraw.h>
#endif
#ifndef __QDOFFSCREEN__
#include <QDOffscreen.h>
#endif
#ifndef __TYPES__
#include <Types.h>
#endif
#ifndef __COMPONENTS__
#include <Components.h>
#endif
#ifndef __STANDARDFILE__
#include <StandardFile.h>
#endif
enum {
#define gestaltCompressionMgr 'icmp'
/* These are the bits that are set in the Component flags, and also in the codecInfo struct. */
#define codecInfoDoes1 (1L<<0) /* codec can work with 1-bit pixels */
#define codecInfoDoes2 (1L<<1) /* codec can work with 2-bit pixels */
#define codecInfoDoes4 (1L<<2) /* codec can work with 4-bit pixels */
#define codecInfoDoes8 (1L<<3) /* codec can work with 8-bit pixels */
#define codecInfoDoes16 (1L<<4) /* codec can work with 16-bit pixels */
#define codecInfoDoes32 (1L<<5) /* codec can work with 32-bit pixels */
#define codecInfoDoesDither (1L<<6) /* codec can do ditherMode */
#define codecInfoDoesStretch (1L<<7) /* codec can stretch to arbitrary sizes */
#define codecInfoDoesShrink (1L<<8) /* codec can shrink to arbitrary sizes */
#define codecInfoDoesMask (1L<<9) /* codec can mask to clipping regions */
#define codecInfoDoesTemporal (1L<<10) /* codec can handle temporal redundancy */
#define codecInfoDoesDouble (1L<<11) /* codec can stretch to double size exactly */
#define codecInfoDoesQuad (1L<<12) /* codec can stretch to quadruple size exactly */
#define codecInfoDoesHalf (1L<<13) /* codec can shrink to half size */
#define codecInfoDoesQuarter (1L<<14) /* codec can shrink to quarter size */
#define codecInfoDoesRotate (1L<<15) /* codec can rotate on decompress */
#define codecInfoDoesHorizFlip (1L<<16) /* codec can flip horizontally on decompress */
#define codecInfoDoesVertFlip (1L<<17) /* codec can flip vertically on decompress */
#define codecInfoDoesSkew (1L<<18) /* codec can skew on decompress */
#define codecInfoDoesBlend (1L<<19) /* codec can blend on decompress */
#define codecInfoDoesWarp (1L<<20) /* codec can warp arbitrarily on decompress */
#define codecInfoDoesRecompress (1L<<21) /* codec can recompress image without accumulating errors */
#define codecInfoDoesSpool (1L<<22) /* codec can spool image data */
#define codecInfoDepth1 (1L<<0) /* compressed data at 1 bpp depth available */
#define codecInfoDepth2 (1L<<1) /* compressed data at 2 bpp depth available */
#define codecInfoDepth4 (1L<<2) /* compressed data at 4 bpp depth available */
#define codecInfoDepth8 (1L<<3) /* compressed data at 8 bpp depth available */
#define codecInfoDepth16 (1L<<4) /* compressed data at 16 bpp depth available */
#define codecInfoDepth32 (1L<<5) /* compressed data at 32 bpp depth available */
#define codecInfoDepth24 (1L<<6) /* compressed data at 24 bpp depth available */
#define codecInfoDepth33 (1L<<7) /* compressed data at 1 bpp monochrome depth available */
#define codecInfoDepth34 (1L<<8) /* compressed data at 2 bpp grayscale depth available */
#define codecInfoDepth36 (1L<<9) /* compressed data at 4 bpp grayscale depth available */
#define codecInfoDepth40 (1L<<10) /* compressed data at 8 bpp grayscale depth available */
#define codecInfoStoresClut (1L<<11) /* compressed data can have custom cluts */
#define codecInfoDoesLossless (1L<<12) /* compressed data can be stored in lossless format */
#define codecFlagUseImageBuffer (1L<<0) /* (input) allocate buffer for whole image on decompress sequence */
#define codecFlagUseScreenBuffer (1L<<1) /* (input) allocate buffer for screen on decompress sequence for faster updates */
#define codecFlagUpdatePrevious (1L<<2) /* (input) udate previous buffer on compress sequence */
#define codecFlagNoScreenUpdate (1L<<3) /* (input) dont update screen, but do update image buffer if allocated */
#define codecFlagWasCompressed (1L<<4) /* (input) hint to compressor that image was previously compressed */
#define codecFlagDontOffscreen (1L<<5) /* return error instead of automatically going offscreen */
#define codecFlagUpdatePreviousComp (1L<<6) /* (input) udate previous buffer on compress sequence */
#define codecFlagForceKeyFrame (1L<<7) /* when sent to CompressSequenceFrame, forces that frame to be a key frame */
#define codecFlagOnlyScreenUpdate (1L<<8) /* (input) only update screen from */
#define codecFlagLiveGrab (1L<<9) /* (input) data being compressed is from live source (speed is critical) */
#define codecFlagUsedNewImageBuffer (1L<<14) /* (output) indicates that image buffer was first used on this decompress sequence */
#define codecFlagUsedImageBuffer (1L<<15) /* (output) indicates that image buffer was used on this decompress sequence */
#define codecErr -8960 /* the codec returned an error */
#define noCodecErr -8961 /* the specified codec could not be found */
#define codecUnimpErr -8962 /* this feature is not implemented by the specified codec */
#define codecSizeErr -8963
#define codecScreenBufErr -8964 /* the screen buffer could not be allocated */
#define codecImageBufErr -8965 /* the image buffer could not be allocated */
#define codecSpoolErr -8966 /* the compressed data must be in memory (spooling did not work) */
#define codecAbortErr -8967 /* the operation was aborted by the progress proc */
#define codecWouldOffscreenErr -8968 /* an offscreen access would have been used, but wasn't allowed because codecFlagDontOffscreen was set */
#define codecBadDataErr -8969 /* compressed data was found to have inconsistencies */
#define codecDataVersErr -8970 /* compressed data was of a format version that codec couldn't handle */
#define codecConditionErr -8972 /* codec can not do requested operation */
#define codecOpenErr -8973 /* the codec could not be opened */
codecMinimumDataSize = 32768 /* The minimum data size for spooling in or out data */
#define compressorComponentType 'imco' /* the type for "Components" which compress images */
#define decompressorComponentType 'imdc' /* the type for "Components" which decompress images */
};
typedef Component CompressorComponent; /* a Component which compresses images */
typedef Component DecompressorComponent; /* a Component which decompresses images */
typedef Component CodecComponent; /* a Component which decompresses or compresses images */
#define anyCodec ((CodecComponent)0) /* take first working codec of given type */
#define bestSpeedCodec ((CodecComponent)-1) /* take fastest codec of given type */
#define bestFidelityCodec ((CodecComponent)-2) /* take codec which is most accurate*/
#define bestCompressionCodec ((CodecComponent)-3) /* take codec of given type that is most accurate */
typedef short sBoolean; /* to make sure stack frames are right */
typedef long CodecType; /* type descriptor for codecs i.e: 'appl','jpeg','rle ' */
typedef unsigned short CodecFlags; /* flags for codec manager calls */
typedef unsigned long CodecQ;
#define codecLosslessQuality 0x400L
#define codecMaxQuality 0x3FFL
#define codecMinQuality 0x000L
#define codecLowQuality 0x100L
#define codecNormalQuality 0x200L
#define codecHighQuality 0x300L
typedef pascal OSErr (*DataProcPtr)(Ptr *dataP,long bytesNeeded,long refCon);
typedef pascal OSErr (*FlushProcPtr)(Ptr data,long bytesAdded,long refCon);
#define codecCompletionSource (1<<0) /* asynchronous codec is done with source data */
#define codecCompletionDest (1<<1) /* asynchronous codec is done with destination data */
typedef pascal void (*CompletionProcPtr)(OSErr result,short flags,long refCon);
enum {
codecProgressOpen = 0,
codecProgressUpdatePercent = 1,
codecProgressClose = 2
};
typedef pascal OSErr (*ProgressProcPtr)(short message,Fixed completeness,long refCon);
typedef long ImageSequence;
struct ProgressProcRecord {
ProgressProcPtr progressProc;
long progressRefCon;
};
typedef struct ProgressProcRecord ProgressProcRecord;
typedef ProgressProcRecord *ProgressProcRecordPtr;
struct CompletionProcRecord {
CompletionProcPtr completionProc;
long completionRefCon;
};
typedef struct CompletionProcRecord CompletionProcRecord;
typedef CompletionProcRecord *CompletionProcRecordPtr;
struct DataProcRecord {
DataProcPtr dataProc;
long dataRefCon;
};
typedef struct DataProcRecord DataProcRecord;
typedef DataProcRecord *DataProcRecordPtr;
struct FlushProcRecord {
FlushProcPtr flushProc;
long flushRefCon;
};
typedef struct FlushProcRecord FlushProcRecord;
typedef FlushProcRecord *FlushProcRecordPtr;
/*
The ImageDescription is private data which is produced when an image or sequence
is compressed. It fully describes the format of the compressed data.*/
struct ImageDescription {
long idSize; /* total size of ImageDescription including extra data ( CLUTs and other per sequence data */
CodecType cType; /* what kind of codec compressed this data */
long resvd1; /* reserved for apple use */
short resvd2; /* reserved for apple use */
short dataRefIndex; /* set to zero */
short version; /* which version is this data */
short revisionLevel; /* what version of that codec did this */
long vendor; /* whose codec compressed this data */
CodecQ temporalQuality; /* what was the temporal quality factor */
CodecQ spatialQuality; /* what was the spatial quality factor */
short width; /* how many pixels wide is this data */
short height; /* how many pixels high is this data */
Fixed hRes; /* horizontal resolution */
Fixed vRes; /* vertical resolution */
long dataSize; /* if known, the size of data for this image descriptor */
short frameCount; /* number of frames this description applies to */
char name[32]; /* name of codec ( in case not installed ) */
short depth; /* what depth is this data (1-32) or ( 33-40 grayscale ) */
short clutID; /* clut id or if 0 clut follows or -1 if no clut */
};
typedef struct ImageDescription ImageDescription;
typedef ImageDescription *ImageDescriptionPtr, **ImageDescriptionHandle;
/*
The CodecInfo is the information returned as the codecInfo struct by a codec Component
to the codec manager or to the caller. It is specific to the particular codec
implementation and not to the codec type.*/
struct CodecInfo {
char typeName[32]; /* name of the codec type i.e.: 'Apple Image Compression' */
short version; /* version of the codec data that this codec knows about */
short revisionLevel; /* revision level of this codec i.e: 0x00010001 (1.0.1) */
long vendor; /* Maker of this codec i.e: 'appl' */
long decompressFlags; /* codecInfo flags for decompression capabilities */
long compressFlags; /* codecInfo flags for compression capabilities */
long formatFlags; /* codecInfo flags for compression format details */
unsigned char compressionAccuracy; /* measure (1-255) of accuracy of this codec for compress (0 if unknown) */
unsigned char decompressionAccuracy; /* measure (1-255) of accuracy of this codec for decompress (0 if unknown) */
unsigned short compressionSpeed; /* ( millisecs for compressing 320x240 on base mac II) (0 if unknown) */
unsigned short decompressionSpeed; /* ( millisecs for decompressing 320x240 on mac II)(0 if unknown) */
unsigned char compressionLevel; /* measure (1-255) of compression level of this codec (0 if unknown) */
char resvd; /* pad */
short minimumHeight; /* minimum height of image (block size) */
short minimumWidth; /* minimum width of image (block size) */
short decompressPipelineLatency; /* in milliseconds ( for asynchronous codecs ) */
short compressPipelineLatency; /* in milliseconds ( for asynchronous codecs ) */
long privateData;
};
typedef struct CodecInfo CodecInfo;
/* Table used for fast dithering. */
struct DitherTable {
long tag;
long seed;
long reserved;
char data[1];
};
typedef struct DitherTable DitherTable;
typedef DitherTable *DTabPtr, **DTabHandle;
/* Name list returned by GetCodecNameList. */
struct CodecNameSpec {
CodecComponent codec;
CodecType cType;
char typeName[32];
Handle name;
};
typedef struct CodecNameSpec CodecNameSpec;
struct CodecNameSpecList {
short count;
CodecNameSpec list[1];
};
typedef struct CodecNameSpecList CodecNameSpecList;
typedef CodecNameSpecList *CodecNameSpecListPtr;
/* Matrix stuff */
struct MatrixRecord {
Fixed matrix[3][3];
};
typedef struct MatrixRecord MatrixRecord;
typedef MatrixRecord *MatrixRecordPtr;
#ifndef _FixedPoint_
#define _FixedPoint_
struct FixedPoint {
Fixed x;
Fixed y;
};
typedef struct FixedPoint FixedPoint;
#endif _FixedPoint_
#ifndef _FixedRect_
#define _FixedRect_
struct FixedRect {
Fixed left;
Fixed top;
Fixed right;
Fixed bottom;
};
typedef struct FixedRect FixedRect;
#endif _FixedRect_
#ifdef __cplusplus
extern "C" {
#endif
pascal OSErr CodecManagerVersion(long *version)
= {0x7000,0xAAA3};
pascal OSErr GetCodecNameList(CodecNameSpecListPtr *list,sBoolean showAll)
= {0x7001,0xAAA3};
pascal OSErr DisposeCodecNameList(CodecNameSpecListPtr list)
= {0x700F,0xAAA3};
pascal OSErr GetCodecInfo(CodecInfo *info,CodecType cType,CodecComponent codec)
= {0x7003,0xAAA3};
pascal OSErr GetMaxCompressionSize(PixMapHandle src,const Rect *srcRect,short colorDepth,
CodecQ quality,CodecType cType,CompressorComponent codec,long *size)
= {0x7004,0xAAA3};
pascal OSErr GetCompressionTime(PixMapHandle src,const Rect *srcRect,short colorDepth,
CodecType cType,CompressorComponent codec,CodecQ *spatialQuality,CodecQ *temporalQuality,
unsigned long *compressTime)
= {0x7005,0xAAA3};
pascal OSErr CompressImage(PixMapHandle src,const Rect *srcRect,CodecQ quality,
CodecType cType,ImageDescriptionHandle desc,Ptr data)
= {0x7006,0xAAA3};
pascal OSErr FCompressImage(PixMapHandle src,const Rect *srcRect,short colorDepth,
CodecQ quality,CodecType cType,CompressorComponent codec,CTabHandle clut,
CodecFlags flags,long bufferSize,FlushProcRecordPtr flushProc,ProgressProcRecordPtr progressProc,
ImageDescriptionHandle desc,Ptr data)
= {0x7007,0xAAA3};
pascal OSErr DecompressImage(Ptr data,ImageDescriptionHandle desc,PixMapHandle dst,
const Rect *srcRect,const Rect *dstRect,short mode,RgnHandle mask)
= {0x7008,0xAAA3};
pascal OSErr FDecompressImage(Ptr data,ImageDescriptionHandle desc,PixMapHandle dst,
const Rect *srcRect,MatrixRecordPtr matrix,short mode,RgnHandle mask,PixMapHandle matte,
const Rect *matteRect,CodecQ accuracy,DecompressorComponent codec,long bufferSize,
DataProcRecordPtr dataProc,ProgressProcRecordPtr progressProc)
= {0x7009,0xAAA3};
pascal OSErr CompressSequenceBegin(ImageSequence *seqID,PixMapHandle src,
PixMapHandle prev,const Rect *srcRect,const Rect *prevRect,short colorDepth,CodecType cType,
CompressorComponent codec,CodecQ spatialQuality,CodecQ temporalQuality,
long keyFrameRate,CTabHandle clut,CodecFlags flags,ImageDescriptionHandle desc)
= {0x700A,0xAAA3};
pascal OSErr CompressSequenceFrame(ImageSequence seqID,PixMapHandle src,
const Rect *srcRect,CodecFlags flags,Ptr data,long *dataSize,unsigned char *similarity,
CompletionProcRecordPtr asyncCompletionProc)
= {0x700B,0xAAA3};
pascal OSErr DecompressSequenceBegin(ImageSequence *seqID,ImageDescriptionHandle desc,
CGrafPtr port,GDHandle gdh,const Rect *srcRect,MatrixRecordPtr matrix,short mode,
RgnHandle mask,CodecFlags flags,CodecQ accuracy,DecompressorComponent codec)
= {0x700D,0xAAA3};
pascal OSErr DecompressSequenceFrame(ImageSequence seqID,Ptr data,CodecFlags inFlags,
CodecFlags *outFlags,CompletionProcRecordPtr asyncCompletionProc)
= {0x700E,0xAAA3};
pascal OSErr SetDSequenceMatrix(ImageSequence seqID,MatrixRecordPtr matrix)
= {0x7010,0xAAA3};
pascal OSErr SetDSequenceMatte(ImageSequence seqID,PixMapHandle matte,const Rect *matteRect)
= {0x7011,0xAAA3};
pascal OSErr SetDSequenceMask(ImageSequence seqID,RgnHandle mask)
= {0x7012,0xAAA3};
pascal OSErr SetDSequenceTransferMode(ImageSequence seqID,short mode,const RGBColor *opColor)
= {0x7013,0xAAA3};
pascal OSErr SetDSequenceDataProc(ImageSequence seqID,DataProcRecordPtr dataProc,
long bufferSize)
= {0x7014,0xAAA3};
pascal OSErr SetDSequenceAccuracy(ImageSequence seqID,CodecQ accuracy)
= {0x7034,0xAAA3};
pascal OSErr SetDSequenceSrcRect(ImageSequence seqID,const Rect *srcRect)
= {0x7035,0xAAA3};
pascal OSErr GetDSequenceImageBuffer(ImageSequence seqID,GWorldPtr *gworld)
= {0x7015,0xAAA3};
pascal OSErr GetDSequenceScreenBuffer(ImageSequence seqID,GWorldPtr *gworld)
= {0x7016,0xAAA3};
pascal OSErr SetCSequenceQuality(ImageSequence seqID,CodecQ spatialQuality,
CodecQ temporalQuality)
= {0x7017,0xAAA3};
pascal OSErr SetCSequencePrev(ImageSequence seqID,PixMapHandle prev,const Rect *prevRect)
= {0x7018,0xAAA3};
pascal OSErr SetCSequenceFlushProc(ImageSequence seqID,FlushProcRecordPtr flushProc,
long bufferSize)
= {0x7033,0xAAA3};
pascal OSErr SetCSequenceKeyFrameRate(ImageSequence seqID,long keyframerate)
= {0x7036,0xAAA3};
pascal OSErr GetCSequencePrevBuffer(ImageSequence seqID,GWorldPtr *gworld)
= {0x7019,0xAAA3};
pascal OSErr CDSequenceBusy(ImageSequence seqID)
= {0x701A,0xAAA3};
pascal OSErr CDSequenceEnd(ImageSequence seqID)
= {0x701B,0xAAA3};
pascal OSErr GetCompressedImageSize(ImageDescriptionHandle desc,Ptr data,
long bufferSize,DataProcRecordPtr dataProc,long *dataSize)
= {0x701C,0xAAA3};
pascal OSErr GetSimilarity(PixMapHandle src,const Rect *srcRect,ImageDescriptionHandle desc,
Ptr data,Fixed *similarity)
= {0x701D,0xAAA3};
pascal OSErr GetImageDescriptionCTable(ImageDescriptionHandle desc,CTabHandle *ctable)
= {0x701E,0xAAA3};
pascal OSErr SetImageDescriptionCTable(ImageDescriptionHandle desc,CTabHandle ctable)
= {0x701F,0xAAA3};
pascal OSErr GetImageDescriptionExtension(ImageDescriptionHandle desc,Handle *extension,
long idType,long index)
= {0x7020,0xAAA3};
pascal OSErr SetImageDescriptionExtension(ImageDescriptionHandle desc,Handle extension,
long idType)
= {0x7021,0xAAA3};
pascal OSErr FindCodec(CodecType cType,CodecComponent specCodec,CompressorComponent *compressor,
DecompressorComponent *decompressor)
= {0x7023,0xAAA3};
pascal OSErr CompressPicture(PicHandle srcPicture,PicHandle dstPicture,
CodecQ quality,CodecType cType)
= {0x7024,0xAAA3};
pascal OSErr FCompressPicture(PicHandle srcPicture,PicHandle dstPicture,
short colorDepth,CTabHandle clut,CodecQ quality,sBoolean doDither,sBoolean compressAgain,
ProgressProcRecordPtr progressProc,CodecType cType,CompressorComponent codec)
= {0x7025,0xAAA3};
pascal OSErr CompressPictureFile(short srcRefNum,short dstRefNum,CodecQ quality,
CodecType cType)
= {0x7026,0xAAA3};
pascal OSErr FCompressPictureFile(short srcRefNum,short dstRefNum,short colorDepth,
CTabHandle clut,CodecQ quality,sBoolean doDither,sBoolean compressAgain,
ProgressProcRecordPtr progressProc,CodecType cType,CompressorComponent codec)
= {0x7027,0xAAA3};
pascal OSErr GetPictureFileHeader(short refNum,Rect *frame,OpenCPicParams *header)
= {0x7028,0xAAA3};
pascal OSErr DrawPictureFile(short refNum,const Rect *frame,ProgressProcRecordPtr progressProc)
= {0x7029,0xAAA3};
pascal OSErr DrawTrimmedPicture(PicHandle srcPicture,const Rect *frame,RgnHandle trimMask,
sBoolean doDither,ProgressProcRecordPtr progressProc)
= {0x702E,0xAAA3};
pascal OSErr DrawTrimmedPictureFile(short srcRefnum,const Rect *frame,RgnHandle trimMask,
sBoolean doDither,ProgressProcRecordPtr progressProc)
= {0x702F,0xAAA3};
pascal OSErr MakeThumbnailFromPicture(PicHandle picture,short colorDepth,
PicHandle thumbnail,ProgressProcRecordPtr progressProc)
= {0x702A,0xAAA3};
pascal OSErr MakeThumbnailFromPictureFile(short refNum,short colorDepth,
PicHandle thumbnail,ProgressProcRecordPtr progressProc)
= {0x702B,0xAAA3};
pascal OSErr MakeThumbnailFromPixMap(PixMapHandle src,const Rect *srcRect,short colorDepth,
PicHandle thumbnail,ProgressProcRecordPtr progressProc)
= {0x702C,0xAAA3};
pascal OSErr TrimImage(ImageDescriptionHandle desc,Ptr inData,long inBufferSize,
DataProcRecordPtr dataProc,Ptr outData,long outBufferSize,FlushProcRecordPtr flushProc,
Rect *trimRect,ProgressProcRecordPtr progressProc)
= {0x702D,0xAAA3};
pascal OSErr ConvertImage(ImageDescriptionHandle srcDD,Ptr srcData,short colorDepth,
CTabHandle clut,CodecQ accuracy,CodecQ quality,CodecType cType,CodecComponent codec,
ImageDescriptionHandle dstDD,Ptr dstData)
= {0x7030,0xAAA3};
pascal OSErr MakeDitherTable(GDHandle gdev,DTabHandle *ditherTable)
= {0x7031,0xAAA3};
pascal OSErr DisposeDitherTable(DTabHandle ditherTable)
= {0x7032,0xAAA3};
pascal void
StdPix(PixMapPtr src,const Rect *srcRect,MatrixRecordPtr matrix,short mode,
RgnHandle mask,PixMapPtr matte,const Rect *matteRect,short flags)
= {0x700C,0xAAA3};
pascal OSErr GetCompressedPixMapInfo(PixMapPtr pix,ImageDescriptionHandle *desc,
Ptr *data,long *bufferSize,DataProcRecord *dataProc,ProgressProcRecord *progressProc)
= {0x7037,0xAAA3};
pascal OSErr SetCompressedPixMapInfo(PixMapPtr pix,ImageDescriptionHandle desc,
Ptr data,long bufferSize,DataProcRecordPtr dataProc,ProgressProcRecordPtr progressProc)
= {0x7038,0xAAA3};
pascal OSErr TransformRgn(MatrixRecordPtr mp,RgnHandle r)
= {0x7039,0xAAA3};
#ifdef __cplusplus
}
#endif
enum {
identityMatrixType = 0x00, /* result if matrix is identity */
translateMatrixType = 0x01, /* result if matrix translates */
scaleMatrixType = 0x02, /* result if matrix scales */
scaleTranslateMatrixType = 0x03, /* result if matrix scales and translates */
linearMatrixType = 0x04, /* result if matrix is general 2 x 2 */
linearTranslateMatrixType = 0x05, /* result if matrix is general 2 x 2 and translates */
perspectiveMatrixType = 0x06 /* result if matrix is general 3 x 3 */
};
typedef unsigned char MatrixFlags;
#ifdef __cplusplus
extern "C" {
#endif
pascal short GetMatrixType(MatrixRecordPtr m)
= {0x7014,0xABC2};
pascal void CopyMatrix(MatrixRecordPtr m1,MatrixRecord *m2)
= {0x7020,0xABC2};
pascal Boolean EqualMatrix(MatrixRecordPtr m1,MatrixRecordPtr m2)
= {0x7021,0xABC2};
pascal void SetIdentityMatrix(MatrixRecord *matrix)
= {0x7015,0xABC2};
pascal void TranslateMatrix(MatrixRecord *m,Fixed deltaH,Fixed deltaV)
= {0x7019,0xABC2};
pascal void RotateMatrix(MatrixRecord *m,Fixed degrees,Fixed aboutX,Fixed aboutY)
= {0x7016,0xABC2};
pascal void ScaleMatrix(MatrixRecord *m,Fixed scaleX,Fixed scaleY,Fixed aboutX,
Fixed aboutY)
= {0x7017,0xABC2};
pascal void SkewMatrix(MatrixRecord *m,Fixed skewX,Fixed skewY,Fixed aboutX,
Fixed aboutY)
= {0x7018,0xABC2};
pascal OSErr TransformFixedPoints(MatrixRecordPtr m,FixedPoint *fpt,long count)
= {0x7022,0xABC2};
pascal OSErr TransformPoints(MatrixRecordPtr mp,Point *pt1,long count)
= {0x7023,0xABC2};
pascal Boolean TransformFixedRect(MatrixRecordPtr m,FixedRect *fr,FixedPoint *fpp)
= {0x7024,0xABC2};
pascal Boolean TransformRect(MatrixRecordPtr m,Rect *r,FixedPoint *fpp)
= {0x7025,0xABC2};
pascal Boolean InverseMatrix(MatrixRecordPtr m,MatrixRecord *im)
= {0x701C,0xABC2};
pascal void ConcatMatrix(MatrixRecordPtr a,MatrixRecord *b)
= {0x701B,0xABC2};
pascal void RectMatrix(MatrixRecord *matrix,Rect *srcRect,Rect *dstRect)
= {0x701E,0xABC2};
pascal void MapMatrix(MatrixRecord *matrix,Rect *fromRect,Rect *toRect)
= {0x701D,0xABC2};
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Standard Preview */
pascal void SFGetFilePreview(Point where,
ConstStr255Param prompt,
FileFilterProcPtr fileFilter,
short numTypes,
SFTypeList typeList,
DlgHookProcPtr dlgHook,
SFReply *reply)
= {0x303C,65,0xAAA3};
pascal void SFPGetFilePreview(Point where,
ConstStr255Param prompt,
FileFilterProcPtr fileFilter,
short numTypes,
SFTypeList typeList,
DlgHookProcPtr dlgHook,
SFReply *reply,
short dlgID,
ModalFilterProcPtr filterProc)
= {0x303C,66,0xAAA3};
pascal void StandardGetFilePreview(FileFilterProcPtr fileFilter,
short numTypes,
SFTypeList typeList,
StandardFileReply *reply)
= {0x303C,67,0xAAA3};
pascal void CustomGetFilePreview(FileFilterYDProcPtr fileFilter,
short numTypes,
SFTypeList typeList,
StandardFileReply *reply,
short dlgID,
Point where,
DlgHookYDProcPtr dlgHook,
ModalFilterYDProcPtr filterProc,
short *activeList,
ActivateYDProcPtr activateProc,
void *yourDataPtr)
= {0x303C,68,0xAAA3};
pascal OSErr MakeFilePreview(short resRefNum, ProgressProcRecordPtr progress)
= {0x303C,69,0xAAA3};
pascal OSErr AddFilePreview(short resRefNum, OSType previewType, Handle previewData)
= {0x303C,70,0xAAA3};
#ifdef __cplusplus
}
#endif
enum {
sfpItemPreviewAreaUser = 11,
sfpItemPreviewStaticText = 12,
sfpItemPreviewDividerUser = 13,
sfpItemCreatePreviewButton = 14,
sfpItemShowPreviewButton = 15
};
struct PreviewResourceRecord {
unsigned long modDate;
short version;
OSType resType;
short resID;
};
typedef struct PreviewResourceRecord PreviewResourceRecord;
typedef PreviewResourceRecord *PreviewResourcePtr, **PreviewResource;
#endif
Reference in New Issue View Git Blame Copy Permalink