{ This file is part of the Free Pascal run time library. Copyright (c) 2005 Karoly Balogh datatypes.library interface unit for MorphOS/PowerPC Based on work of Nils Sjoholm member of the Amiga RTL development team. MorphOS port was done on a free Pegasos II/G4 machine provided by Genesi S.a.r.l. See the file COPYING.FPC, included in this distribution, for details about the copyright. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. **********************************************************************} {$INLINE ON} {$PACKRECORDS 2} unit datatypes; interface uses exec, doslib, intuition, utility, graphics{, iffparse, amigaprinter, prtbase}; const {***************************************************************************} ID_DTYP = 1146378576; {***************************************************************************} ID_DTHD = 1146374212; Type pDataTypeHeader = ^tDataTypeHeader; tDataTypeHeader = record dth_Name, { Descriptive name of the data type } dth_BaseName, { Base name of the data type } dth_Pattern : PChar; { Match pattern for file name. } dth_Mask : Pointer; { Comparision mask } dth_GroupID, { Group that the DataType is in } dth_ID : longword; { ID for DataType (same as IFF FORM type) } dth_MaskLen, { Length of comparision mask } dth_Pad : smallint; { Unused at present (must be 0) } dth_Flags, { Flags } dth_Priority : WORD; { Priority } end; const DTHSIZE = 32; {***************************************************************************} { Basic type } DTF_TYPE_MASK = $000F; DTF_BINARY = $0000; DTF_ASCII = $0001; DTF_IFF = $0002; DTF_MISC = $0003; { Set if case is important } DTF_CASE = $0010; { Reserved for system use } DTF_SYSTEM1 = $1000; {**************************************************************************** * * GROUP ID and ID * * This is used for filtering out objects that you don't want. For * example, you could make a filter for the ASL file requester so * that it only showed the files that were pictures, or even to * narrow it down to only show files that were ILBM pictures. * * Note that the Group ID's are in lower case, and always the first * four characters of the word. * * For ID's; If it is an IFF file, then the ID is the same as the * FORM type. If it isn't an IFF file, then the ID would be the * first four characters of name for the file type. * ****************************************************************************} { System file, such as; directory, executable, library, device, font, etc. } GID_SYSTEM = 1937339252; { Formatted or unformatted text } GID_TEXT = 1952807028; { Formatted text with graphics or other DataTypes } GID_DOCUMENT = 1685021557; { Sound } GID_SOUND = 1936684398; { Musical instruments used for musical scores } GID_INSTRUMENT = 1768846196; { Musical score } GID_MUSIC = 1836413801; { Still picture } GID_PICTURE = 1885954932; { Animated picture } GID_ANIMATION = 1634625901; { Animation with audio track } GID_MOVIE = 1836021353; {***************************************************************************} { A code chunk contains an embedded executable that can be loaded * with InternalLoadSeg. } ID_CODE = 1146372932; Type { DataTypes comparision hook context (Read-Only). This is the * argument that is passed to a custom comparision routine. } pDTHookContext = ^tDTHookContext; tDTHookContext = record { Libraries that are already opened for your use } dthc_SysBase, dthc_DOSBase, dthc_IFFParseBase, dthc_UtilityBase : pLibrary; { File context } dthc_Lock : longword; { Lock on the file } dthc_FIB : pFileInfoBlock; { Pointer to a FileInfoBlock } dthc_FileHandle : longword; { Pointer to the file handle (may be NULL) } {$WARNING FIX ME!!! IFF handle type} // dthc_IFF : pIFFHandle; { Pointer to an IFFHandle (may be NULL) } dthc_IFF : Pointer; { Pointer to an IFFHandle (may be NULL) } dthc_Buffer : PChar; { Buffer } dthc_BufferLength : longword; { Length of the buffer } end; {***************************************************************************} const ID_TOOL = 1146377292; Type pTool = ^tTool; tTool = record tn_Which, { Which tool is this } tn_Flags : WORD; { Flags } tn_Program : PChar; { Application to use } end; const TSIZE = 8; { defines for tn_Which } TW_INFO = 1; TW_BROWSE = 2; TW_EDIT = 3; TW_PRINT = 4; TW_MAIL = 5; { defines for tn_Flags } TF_LAUNCH_MASK = $000F; TF_SHELL = $0001; TF_WORKBENCH = $0002; TF_RX = $0003; {***************************************************************************} ID_TAGS = 1146377287; {***************************************************************************} Type pDataType = ^tDataType; tDataType = record dtn_Node1, { Reserved for system use } dtn_Node2 : tNode; { Reserved for system use } dtn_Header : pDataTypeHeader; { Pointer to the DataTypeHeader } dtn_ToolList: tList; { List of tool nodes } dtn_FunctionName : PChar; { Name of comparision routine } dtn_AttrList : pTagItem; { Object creation tags } dtn_Length : longword; { Length of the memory block } end; {***************************************************************************} pToolNode = ^tToolNode; tToolNode = Record tn_Node : tNode; { Embedded node } tn_Tool : tTool; { Embedded tool } tn_Length : longword; { Length of the memory block } end; {***************************************************************************} const ID_NAME = 1312902469; {***************************************************************************} { text ID's } DTERROR_UNKNOWN_DATATYPE = 2000; DTERROR_COULDNT_SAVE = 2001; DTERROR_COULDNT_OPEN = 2002; DTERROR_COULDNT_SEND_MESSAGE = 2003; { new for V40 } DTERROR_COULDNT_OPEN_CLIPBOARD = 2004; DTERROR_Reserved = 2005; DTERROR_UNKNOWN_COMPRESSION = 2006; DTERROR_NOT_ENOUGH_DATA = 2007; DTERROR_INVALID_DATA = 2008; { New for V44 } DTERROR_NOT_AVAILABLE = 2009; { Offset for types } DTMSG_TYPE_OFFSET = 2100; {***************************************************************************} DATATYPESCLASS : Pchar = 'datatypesclass'; {***************************************************************************} DTA_Dummy = (TAG_USER+$1000); { Generic attributes } DTA_TextAttr = (DTA_Dummy+10); { (struct TextAttr ) Pointer to the default TextAttr to use for * the text within the object. } DTA_TopVert = (DTA_Dummy+11); { (LONG) Current top vertical unit } DTA_VisibleVert = (DTA_Dummy+12); { (LONG) Number of visible vertical units } DTA_TotalVert = (DTA_Dummy+13); { (LONG) Total number of vertical units } DTA_VertUnit = (DTA_Dummy+14); { (LONG) Number of pixels per vertical unit } DTA_TopHoriz = (DTA_Dummy+15); { (LONG) Current top horizontal unit } DTA_VisibleHoriz = (DTA_Dummy+16); { (LONG) Number of visible horizontal units } DTA_TotalHoriz = (DTA_Dummy+17); { (LONG) Total number of horizontal units } DTA_HorizUnit = (DTA_Dummy+18); { (LONG) Number of pixels per horizontal unit } DTA_NodeName = (DTA_Dummy+19); { (UBYTE ) Name of the current element within the object. } DTA_Title = (DTA_Dummy+20); { (UBYTE ) Title of the object. } DTA_TriggerMethods = (DTA_Dummy+21); { (struct DTMethod ) Pointer to a NULL terminated array of * supported trigger methods. } DTA_Data = (DTA_Dummy+22); { (Pointer) Object specific data. } DTA_TextFont = (DTA_Dummy+23); { (struct TextFont ) Default font to use for text within the * object. } DTA_Methods = (DTA_Dummy+24); { (longword ) Pointer to a ~0 terminated array of supported * methods. } DTA_PrinterStatus = (DTA_Dummy+25); { (LONG) Printer error message. Error numbers are defined in * } DTA_PrinterProc = (DTA_Dummy+26); { PRIVATE (struct Process ) Pointer to the print process. } DTA_LayoutProc = (DTA_Dummy+27); { PRIVATE (struct Process ) Pointer to the layout process. } DTA_Busy = (DTA_Dummy+28); { Used to turn the applications' busy pointer off and on } DTA_Sync = (DTA_Dummy+29); { Used to indicate that new information has been loaded into * an object. This is for models that cache the DTA_TopVert- * like tags } DTA_BaseName = (DTA_Dummy+30); { The base name of the class } DTA_GroupID = (DTA_Dummy+31); { Group that the object must belong in } DTA_ErrorLevel = (DTA_Dummy+32); { Error level } DTA_ErrorNumber = (DTA_Dummy+33); { datatypes.library error number } DTA_ErrorString = (DTA_Dummy+34); { Argument for datatypes.library error } DTA_Conductor = (DTA_Dummy+35); { New for V40. (UBYTE ) specifies the name of the * realtime.library conductor. Defaults to "Main". } DTA_ControlPanel = (DTA_Dummy+36); { New for V40. (BOOL) Indicate whether a control panel should be * embedded within the object (in the animation datatype, for * example). Defaults to TRUE. } DTA_Immediate = (DTA_Dummy+37); { New for V40. (BOOL) Indicate whether the object should * immediately begin playing. Defaults to FALSE. } DTA_Repeat = (DTA_Dummy+38); { New for V40. (BOOL) Indicate that the object should repeat * playing. Defaults to FALSE. } { New for V44. Address of a DTST_MEMORY source type * object (Pointer). } DTA_SourceAddress = (DTA_Dummy+39); { New for V44. Size of a DTST_MEMORY source type * object (longword). } DTA_SourceSize = (DTA_Dummy+40); { Reserved tag; DO NOT USE (V44) } DTA_Reserved = (DTA_Dummy+41); { DTObject attributes } DTA_Name = (DTA_Dummy+100); DTA_SourceType = (DTA_Dummy+101); DTA_Handle = (DTA_Dummy+102); DTA_DataType = (DTA_Dummy+103); DTA_Domain = (DTA_Dummy+104); { DON'T USE THE FOLLOWING FOUR TAGS. USE THE CORRESPONDING TAGS IN * } DTA_Left = (DTA_Dummy+105); DTA_Top = (DTA_Dummy+106); DTA_Width = (DTA_Dummy+107); DTA_Height = (DTA_Dummy+108); DTA_ObjName = (DTA_Dummy+109); DTA_ObjAuthor = (DTA_Dummy+110); DTA_ObjAnnotation = (DTA_Dummy+111); DTA_ObjCopyright = (DTA_Dummy+112); DTA_ObjVersion = (DTA_Dummy+113); DTA_ObjectID = (DTA_Dummy+114); DTA_UserData = (DTA_Dummy+115); DTA_FrameInfo = (DTA_Dummy+116); { DON'T USE THE FOLLOWING FOUR TAGS. USE THE CORRESPONDING TAGS IN * } DTA_RelRight = (DTA_Dummy+117); DTA_RelBottom = (DTA_Dummy+118); DTA_RelWidth = (DTA_Dummy+119); DTA_RelHeight = (DTA_Dummy+120); DTA_SelectDomain = (DTA_Dummy+121); DTA_TotalPVert = (DTA_Dummy+122); DTA_TotalPHoriz = (DTA_Dummy+123); DTA_NominalVert = (DTA_Dummy+124); DTA_NominalHoriz = (DTA_Dummy+125); { Printing attributes } DTA_DestCols = (DTA_Dummy+400); { (LONG) Destination X width } DTA_DestRows = (DTA_Dummy+401); { (LONG) Destination Y height } DTA_Special = (DTA_Dummy+402); { (UWORD) Option flags } DTA_RastPort = (DTA_Dummy+403); { (struct RastPort ) RastPort to use when printing. (V40) } DTA_ARexxPortName = (DTA_Dummy+404); { (PChar) Pointer to base name for ARexx port (V40) } {***************************************************************************} DTST_RAM = 1; DTST_FILE = 2; DTST_CLIPBOARD = 3; DTST_HOTLINK = 4; DTST_MEMORY = 5; { New for V44 } {***************************************************************************} { Attached to the Gadget.SpecialInfo field of the gadget. Don't access directly, * use the Get/Set calls instead. } Type pDTSpecialInfo = ^tDTSpecialInfo; tDTSpecialInfo = record si_Lock : tSignalSemaphore; { Locked while in DoAsyncLayout() } si_Flags, si_TopVert, { Top row (in units) } si_VisVert, { Number of visible rows (in units) } si_TotVert, { Total number of rows (in units) } si_OTopVert, { Previous top (in units) } si_VertUnit, { Number of pixels in vertical unit } si_TopHoriz, { Top column (in units) } si_VisHoriz, { Number of visible columns (in units) } si_TotHoriz, { Total number of columns (in units) } si_OTopHoriz, { Previous top (in units) } si_HorizUnit : Longint; { Number of pixels in horizontal unit } end; const { Object is in layout processing } DTSIF_LAYOUT = 1; { Object needs to be layed out } DTSIF_NEWSIZE = 2; DTSIF_DRAGGING = 4; DTSIF_DRAGSELECT = 8; DTSIF_HIGHLIGHT = 16; { Object is being printed } DTSIF_PRINTING = 32; { Object is in layout process } DTSIF_LAYOUTPROC = 64; {***************************************************************************} Type pDTMethod = ^tDTMethod; tDTMethod = record dtm_Label, dtm_Command : PChar; dtm_Method : longword; end; {***************************************************************************} Const DTM_Dummy = ($600); { Inquire what environment an object requires } DTM_FRAMEBOX = ($601); { Same as GM_LAYOUT except guaranteed to be on a process already } DTM_PROCLAYOUT = ($602); { Layout that is occurring on a process } DTM_ASYNCLAYOUT = ($603); { When a RemoveDTObject() is called } DTM_REMOVEDTOBJECT = ($604); DTM_SELECT = ($605); DTM_CLEARSELECTED = ($606); DTM_COPY = ($607); DTM_PRINT = ($608); DTM_ABORTPRINT = ($609); DTM_NEWMEMBER = ($610); DTM_DISPOSEMEMBER = ($611); DTM_GOTO = ($630); DTM_TRIGGER = ($631); DTM_OBTAINDRAWINFO = ($640); DTM_DRAW = ($641); DTM_RELEASEDRAWINFO = ($642); DTM_WRITE = ($650); { Used to ask the object about itself } type pFrameInfo = ^tFrameInfo; tFrameInfo = record fri_PropertyFlags : longword; fri_Resolution : tPoint; fri_RedBits : BYTE; fri_GreenBits : BYTE; fri_BlueBits : BYTE; fri_Dimensions : record Width : longword; Height : longword; Depth : longword; end; fri_Screen : pScreen; fri_ColorMap : pColorMap; fri_Flags : longword; end; CONST FIF_SCALABLE = $1; FIF_SCROLLABLE = $2; FIF_REMAPPABLE = $4; { DTM_REMOVEDTOBJECT, DTM_CLEARSELECTED, DTM_COPY, DTM_ABORTPRINT } Type pdtGeneral = ^tdtGeneral; tdtGeneral = record MethodID : longword; dtg_GInfo : pGadgetInfo; end; { DTM_SELECT } pdtSelect = ^tdtSelect; tdtSelect = record MethodID : longword; dts_GInfo : pGadgetInfo; dts_Select : tRectangle; end; { DTM_FRAMEBOX } pdtFrameBox = ^tdtFrameBox; tdtFrameBox = record MethodID : longword; dtf_GInfo : pGadgetInfo; dtf_ContentsInfo, { Input } dtf_FrameInfo : pFrameInfo; { Output } dtf_SizeFrameInfo, dtf_FrameFlags : longword; end; { DTM_GOTO } pdtGoto = ^tdtGoto; tdtGoto = record MethodID : longword; dtg_GInfo : pGadgetInfo; dtg_NodeName : PChar; { Node to goto } dtg_AttrList : pTagItem; { Additional attributes } end; { DTM_TRIGGER } pdtTrigger = ^tdtTrigger; tdtTrigger = record MethodID : longword; dtt_GInfo : pGadgetInfo; dtt_Function : longword; dtt_Data : Pointer; end; const STM_PAUSE = 1 ; STM_PLAY = 2 ; STM_CONTENTS = 3 ; STM_INDEX = 4 ; STM_RETRACE = 5 ; STM_BROWSE_PREV = 6 ; STM_BROWSE_NEXT = 7 ; STM_NEXT_FIELD = 8 ; STM_PREV_FIELD = 9 ; STM_ACTIVATE_FIELD = 10; STM_COMMAND = 11; { New for V40 } STM_REWIND = 12; STM_FASTFORWARD = 13; STM_STOP = 14; STM_RESUME = 15; STM_LOCATE = 16; Type { Printer IO request } pprinterIO = ^tprinterIO; tprinterIO = record ios : tIOStdReq; {$WARNING FIX ME!!! TPrinterIO} { iodrp : tIODRPReq; iopc : tIOPrtCmdReq; } end; { DTM_PRINT } pdtPrint = ^tdtPrint; tdtPrint = record MethodID : longword; dtp_GInfo : pGadgetInfo; dtp_PIO : pprinterIO; dtp_AttrList : pTagItem; end; { DTM_DRAW } pdtDraw = ^tdtDraw; tdtDraw = record MethodID : longword; dtd_RPort : pRastPort; dtd_Left, dtd_Top, dtd_Width, dtd_Height, dtd_TopHoriz, dtd_TopVert : Longint; dtd_AttrList : pTagItem; { Additional attributes } end; { DTM_WRITE } pdtWrite = ^tdtWrite; tdtWrite = record MethodID : longword; dtw_GInfo : pGadgetInfo; { Gadget information } dtw_FileHandle : longword; { File handle to write to } dtw_Mode : longword; dtw_AttrList : pTagItem; { Additional attributes } end; const { Save data as IFF data } DTWM_IFF = 0; { Save data as local data format } DTWM_RAW = 1; {***************************************************************************} PICTUREDTCLASS : PChar = 'picture.datatype'; {***************************************************************************} { Picture attributes } PDTA_ModeID = (DTA_Dummy + 200); { Mode ID of the picture } PDTA_BitMapHeader = (DTA_Dummy + 201); PDTA_BitMap = (DTA_Dummy + 202); { Pointer to a class-allocated bitmap, that will end * up being freed by picture.class when DisposeDTObject() * is called } { Picture colour table (struct ColorRegister *) } PDTA_ColorRegisters = (DTA_Dummy + 203); { Color table to use with SetRGB32CM() (longword *) } PDTA_CRegs = (DTA_Dummy + 204); { Color table; this table is initialized during the layout * process and will contain the colours the picture will use * after remapping. If no remapping takes place, these colours * will match those in the PDTA_CRegs table (longword *). } PDTA_GRegs = (DTA_Dummy + 205); { Shared pen table; this table is initialized during the layout * process while the picture is being remapped (UBYTE *). } PDTA_ColorTable = (DTA_Dummy + 206); { Shared pen table; in most places this table will be identical to * the PDTA_ColorTable table. Some of the colours in this table might * match the original colour palette a little better than the colours * picked for the other table. The picture.datatype uses the two tables * during remapping, alternating for each pixel (UBYTE *). } PDTA_ColorTable2 = (DTA_Dummy + 207); { OBSOLETE; DO NOT USE } PDTA_Allocated = (DTA_Dummy + 208); { Number of colors used by the picture. (UWORD) } PDTA_NumColors = (DTA_Dummy + 209); { Number of colors allocated by the picture (UWORD) } PDTA_NumAlloc = (DTA_Dummy + 210); PDTA_Remap = (DTA_Dummy + 211); { Boolean : Remap picture (defaults to TRUE) } PDTA_Screen = (DTA_Dummy + 212); { Screen to remap to } PDTA_FreeSourceBitMap = (DTA_Dummy + 213); { Boolean : Free the source bitmap after remapping } PDTA_Grab = (DTA_Dummy + 214); { Pointer to a Point structure } PDTA_DestBitMap = (DTA_Dummy + 215); { Pointer to the destination (remapped) bitmap } PDTA_ClassBitMap = (DTA_Dummy + 216); { Pointer to class-allocated bitmap, that will end * up being freed by the class after DisposeDTObject() * is called } PDTA_NumSparse = (DTA_Dummy + 217); { (UWORD) Number of colors used for sparse remapping } PDTA_SparseTable = (DTA_Dummy + 218); { (UBYTE *) Pointer to a table of pen numbers indicating * which colors should be used when remapping the image. * This array must contain as many entries as there * are colors specified with PDTA_NumSparse } { Index number of the picture to load (longword). (V44) } PDTA_WhichPicture = (DTA_Dummy + 219); { Get the number of pictures stored in the file (longword *). (V44) } PDTA_GetNumPictures = (DTA_Dummy + 220); { Maximum number of colours to use for dithering (longword). (V44) } PDTA_MaxDitherPens = (DTA_Dummy + 221); { Quality of the dithering algorithm to be used during colour * quantization (longword). (V44) } PDTA_DitherQuality = (DTA_Dummy + 222); { Pointer to the allocated pen table (UBYTE *). (V44) } PDTA_AllocatedPens = (DTA_Dummy + 223); { Quality for scaling. (V45) } PDTA_ScaleQuality = (DTA_Dummy + 224); {***************************************************************************} { When querying the number of pictures stored in a file, the * following value denotes "the number of pictures is unknown". } PDTANUMPICTURES_Unknown = (0); {***************************************************************************} { V43 extensions (attributes) } { Set the sub datatype interface mode (LONG); see "Interface modes" below } PDTA_SourceMode = (DTA_Dummy + 250); { Set the app datatype interface mode (LONG); see "Interface modes" below } PDTA_DestMode = (DTA_Dummy + 251); { Allocates the resulting bitmap as a friend bitmap (BOOL) } PDTA_UseFriendBitMap = (DTA_Dummy + 255); { NULL or mask plane for use with BltMaskBitMapRastPort() (PLANEPTR) } PDTA_MaskPlane = (DTA_Dummy + 258); PDTA_Displayable = (DTA_Dummy + 259); { * defaults to TRUE * } {***************************************************************************} { Interface modes } PMODE_V42 = (0); { Compatibility mode } PMODE_V43 = (1); { Extended mode } {***************************************************************************} { V43 extensions (methods) } PDTM_Dummy = (DTM_Dummy + $60); { Transfer pixel data to the picture object in the specified format } PDTM_WRITEPIXELARRAY = (PDTM_Dummy + 0); { Transfer pixel data from the picture object in the specified format } PDTM_READPIXELARRAY = (PDTM_Dummy + 1); {***************************************************************************} { * Pixel formats * } PBPAFMT_RGB = 0; PBPAFMT_RGBA = 1; PBPAFMT_ARGB = 2; PBPAFMT_LUT8 = 3; PBPAFMT_GREY8 = 4; { Masking techniques } mskNone = 0; mskHasMask = 1; mskHasTransparentColor = 2; mskLasso = 3; mskHasAlpha = 4; { Compression techniques } cmpNone = 0; cmpByteRun1 = 1; cmpByteRun2 = 2; Type { Bitmap header (BMHD) structure } pBitMapHeader = ^tBitMapHeader; tBitMapHeader = record bmh_Width, { Width in pixels } bmh_Height : Word; { Height in pixels } bmh_Left, { Left position } bmh_Top : smallint; { Top position } bmh_Depth, { Number of planes } bmh_Masking, { Masking type } bmh_Compression, { Compression type } bmh_Pad : Byte; bmh_Transparent : WORD; { Transparent color } bmh_XAspect, bmh_YAspect : Byte; bmh_PageWidth, bmh_PageHeight : smallint; end; {***************************************************************************} { Color register structure } pColorRegister = ^tColorRegister; tColorRegister = record red, green, blue : Byte; end; {***************************************************************************} const { IFF types that may be in pictures } ID_ILBM = 1229734477; ID_BMHD = 1112361028; ID_BODY = 1112491097; ID_CMAP = 1129136464; ID_CRNG = 1129467463; ID_GRAB = 1196572994; ID_SPRT = 1397772884; ID_DEST = 1145394004; ID_CAMG = 1128353095; {***************************************************************************} SOUNDDTCLASS : PChar = 'sound.datatype'; {***************************************************************************} { Sound attributes } SDTA_Dummy = (DTA_Dummy + 500); SDTA_VoiceHeader = (SDTA_Dummy + 1); SDTA_Sample = (SDTA_Dummy + 2); { (UBYTE *) Sample data } SDTA_SampleLength = (SDTA_Dummy + 3); { (longword) Length of the sample data in UBYTEs } SDTA_Period = (SDTA_Dummy + 4); { (UWORD) Period } SDTA_Volume = (SDTA_Dummy + 5); { (UWORD) Volume. Range from 0 to 64 } SDTA_Cycles = (SDTA_Dummy + 6); { The following tags are new for V40 } SDTA_SignalTask = (SDTA_Dummy + 7); { (struct Task *) Task to signal when sound is complete or next buffer needed. } { (longword) Signal mask to use on completion or 0 to disable * * NOTE: Due to a bug in sound.datatype V40 SDTA_SignalBit * was actually implemented as a signal mask as opposed * to a bit number. The documentation now reflects * this. If you intend to use a signal bit number * instead of the mask, use the new V44 tag * SDTA_SignalBitNumber below. *} SDTA_SignalBit = (SDTA_Dummy + 8); SDTA_SignalBitMask = SDTA_SignalBit; { (BYTE) Signal bit to use on completion or -1 to disable } SDTA_Continuous = (SDTA_Dummy + 9); { (longword) Playing a continuous stream of data. Defaults to FALSE. } { The following tags are new for V44 } { (BYTE) Signal bit to use on completion or -1 to disable } SDTA_SignalBitNumber = (SDTA_Dummy + 10); { (UWORD) Samples per second } SDTA_SamplesPerSec = (SDTA_Dummy + 11); { (struct timeval *) Sample replay period } SDTA_ReplayPeriod = (SDTA_Dummy + 12); { (BYTE *) Sample data } SDTA_LeftSample = (SDTA_Dummy + 13); SDTA_RightSample = (SDTA_Dummy + 14); { (BYTE) Stereo panning } SDTA_Pan = (SDTA_Dummy + 15); { (BOOL) FreeVec() all sample data upon OM_DISPOSE. } SDTA_FreeSampleData = (SDTA_Dummy + 16); { (BOOL) Wait for the current sample to be played back before * switching to the new sample data. } SDTA_SyncSampleChange = (SDTA_Dummy + 17); {***************************************************************************} CMP_NONE = 0; CMP_FIBDELTA = 1; Type pVoiceHeader = ^tVoiceHeader; tVoiceHeader = record vh_OneShotHiSamples, vh_RepeatHiSamples, vh_SamplesPerHiCycle : longword; vh_SamplesPerSec : WORD; vh_Octaves, vh_Compression : Byte; vh_Volume : longword; end; {***************************************************************************} const { Channel allocation } SAMPLETYPE_Left = (2); SAMPLETYPE_Right = (4); SAMPLETYPE_Stereo = (6); { IFF types } ID_8SVX = 944985688; ID_VHDR = 1447576658; ID_CHAN = $4348414E; {***************************************************************************} { ***************************************************************************} TEXTDTCLASS : PChar = 'text.datatype'; { ***************************************************************************} { Text attributes } TDTA_Buffer = (DTA_Dummy + 300); TDTA_BufferLen = (DTA_Dummy + 301); TDTA_LineList = (DTA_Dummy + 302); TDTA_WordSelect = (DTA_Dummy + 303); TDTA_WordDelim = (DTA_Dummy + 304); TDTA_WordWrap = (DTA_Dummy + 305); { Boolean. Should the text be word wrapped. Defaults to false. } { ***************************************************************************} Type { There is one Line structure for every line of text in our document. } pLine = ^tLine; tLine = record ln_Link : tMinNode; { to link the lines together } ln_Text : PChar; { pointer to the text for this line } ln_TextLen : longword; { the character length of the text for this line } ln_XOffset, { where in the line the text starts } ln_YOffset, { line the text is on } ln_Width, { Width of line in pixels } ln_Height, { Height of line in pixels } ln_Flags : WORD; { info on the line } ln_FgPen, { foreground pen } ln_BgPen : Shortint; { background pen } ln_Style : longword; { Font style } ln_Data : Pointer; { Link data... } end; { ***************************************************************************} const { Line.ln_Flags } { Line Feed } LNF_LF = 1; { Segment is a link } LNF_LINK = 2; { ln_Data is a pointer to an DataTypes object } LNF_OBJECT = 4; { Object is selected } LNF_SELECTED = 8; { ***************************************************************************} { IFF types that may be text } ID_FTXT = 1179932756; ID_CHRS = 1128813139; { ***************************************************************************} ANIMATIONDTCLASS : PChar = 'animation.datatype'; { ***************************************************************************} { Animation attributes } ADTA_Dummy = (DTA_Dummy + 600); ADTA_ModeID = PDTA_ModeID ; ADTA_KeyFrame = PDTA_BitMap ; { (struct BitMap *) Key frame (first frame) bitmap } ADTA_ColorRegisters = PDTA_ColorRegisters; ADTA_CRegs = PDTA_CRegs ; ADTA_GRegs = PDTA_GRegs ; ADTA_ColorTable = PDTA_ColorTable ; ADTA_ColorTable2 = PDTA_ColorTable2 ; ADTA_Allocated = PDTA_Allocated ; ADTA_NumColors = PDTA_NumColors ; ADTA_NumAlloc = PDTA_NumAlloc ; ADTA_Remap = PDTA_Remap; { (BOOL) : Remap animation (defaults to TRUE) } ADTA_Screen = PDTA_Screen; { (struct Screen *) Screen to remap to } ADTA_NumSparse = PDTA_NumSparse; { (UWORD) Number of colors used for sparse remapping } ADTA_SparseTable = PDTA_SparseTable; { (UBYTE *) Pointer to a table of pen numbers indicating * which colors should be used when remapping the image. * This array must contain as many entries as there * are colors specified with ADTA_NumSparse } ADTA_Width = (ADTA_Dummy + 1); ADTA_Height = (ADTA_Dummy + 2); ADTA_Depth = (ADTA_Dummy + 3); ADTA_Frames = (ADTA_Dummy + 4); { (longword) Number of frames in the animation } ADTA_Frame = (ADTA_Dummy + 5); { (longword) Current frame } ADTA_FramesPerSecond = (ADTA_Dummy + 6); { (longword) Frames per second } ADTA_FrameIncrement = (ADTA_Dummy + 7); { (LONG) Amount to change frame by when fast forwarding or * rewinding. Defaults to 10. } ADTA_PreloadFrameCount = (ADTA_Dummy + 8); { (V44) } { Sound attributes } ADTA_Sample = SDTA_Sample ; ADTA_SampleLength = SDTA_SampleLength; ADTA_Period = SDTA_Period ; ADTA_Volume = SDTA_Volume ; ADTA_Cycles = SDTA_Cycles ; ADTA_LeftSample = SDTA_LeftSample; { (V44) } ADTA_RightSample = SDTA_RightSample; { (V44) } ADTA_SamplesPerSec = SDTA_SamplesPerSec; { (V44) } { ***************************************************************************} ID_ANIM = 1095649613; ID_ANHD = 1095649348; ID_DLTA = 1145852993; { ***************************************************************************} { Required ANHD structure describes an ANIM frame } Type pAnimHeader = ^tAnimHeader; tAnimHeader = record ah_Operation : Byte; { The compression method: 0 set directly (normal ILBM BODY), 1 XOR ILBM mode, 2 Long Delta mode, 3 Short Delta mode, 4 Generalized short/long Delta mode, 5 Byte Vertical Delta mode 6 Stereo op 5 (third party) 74 (ascii 'J') reserved for Eric Graham's compression technique (details to be released later). } ah_Mask : Byte; { (XOR mode only - plane mask where each bit is set =1 if there is data and =0 if not.) } ah_Width, { (XOR mode only - width and height of the } ah_Height, { area represented by the BODY to eliminate } { unnecessary un-changed data) } ah_Left, { (XOR mode only - position of rectangular } ah_Top : WORD; { area representd by the BODY) } ah_AbsTime, { Timing for a frame relative to the time the first frame was displayed, in jiffies (1/60 sec) } ah_RelTime : longword; { Timing for frame relative to time previous frame was displayed - in jiffies (1/60 sec) } ah_Interleave, { Indicates how may frames back this data is to modify. 0 defaults to indicate two frames back (for double buffering). n indicates n frames back. The main intent here is to allow values of 1 for special applications where frame data would modify the immediately previous frame. } ah_Pad0 : Byte; { Pad byte, not used at present. } ah_Flags : longword; { 32 option bits used by options=4 and 5. At present only 6 are identified, but the rest are set =0 so they can be used to implement future ideas. These are defined for option 4 only at this point. It is recommended that all bits be set =0 for option 5 and that any bit settings used in the future (such as for XOR mode) be compatible with the option 4 bit settings. Player code should check undefined bits in options 4 and 5 to assure they are zero. The six bits for current use are: bit # set =0 set =1 =============================================== 0 short data long data 1 set XOR 2 separate info one info list for each plane for all planes 3 not RLC RLC (run length coded) 4 horizontal vertical 5 short info offsets long info offsets } ah_Pad : Array[0..15] of Byte; { This is a pad for future use for future compression modes. } end; { ***************************************************************************} const ADTM_Dummy = ($700); ADTM_LOADFRAME = ($701); { Used to load a frame of the animation } ADTM_UNLOADFRAME = ($702); { Used to unload a frame of the animation } ADTM_START = ($703); { Used to start the animation } ADTM_PAUSE = ($704); { Used to pause the animation (don't reset the timer) } ADTM_STOP = ($705); { Used to stop the animation } ADTM_LOCATE = ($706); { Used to locate a frame in the animation (as set by a slider...) } { Used to load a new format frame of the animation (V44) } ADTM_LOADNEWFORMATFRAME = ($707); { Used to unload a new format frame of the animation (V44) } ADTM_UNLOADNEWFORMATFRAME = ($708); { ***************************************************************************} { ADTM_LOADFRAME, ADTM_UNLOADFRAME } Type padtFrame = ^tadtFrame; tadtFrame = record MethodID, alf_TimeStamp, { Timestamp of frame to load } { The following fields are filled in by the ADTM_LOADFRAME method, } { and are read-only for any other methods. } alf_Frame, { Frame number } alf_Duration : longword; { Duration of frame } alf_BitMap : pBitMap; { Loaded BitMap } alf_CMap : pColorMap; { Colormap, if changed } alf_Sample : Pointer; { Sound data } alf_SampleLength, alf_Period : longword; alf_UserData : Pointer; { Used by load frame for extra data } end; { ADTM_LOADNEWFORMATFRAME, ADTM_UNLOADNEWFORMATFRAME } PadtNewFormatFrame = ^tadtNewFormatFrame; tadtNewFormatFrame = record MethodID : longword; alf_TimeStamp : longword; { Timestamp of frame to load } { The following fields are filled in by the ADTM_NEWLOADFRAME method, } { and are read-only for any other methods. } alf_Frame : longword; { Frame number } alf_Duration : longword; { Duration of frame } alf_BitMap : PBitMap; { Loaded BitMap } alf_CMap : PColorMap; { Colormap, if changed } alf_Sample : PBYTE; alf_SampleLength : longword; { Sound data } alf_Period : longword; alf_UserData : Pointer; { Used by load frame for extra data } alf_Size : longword; { Size of this data structure (in bytes) } alf_LeftSample : PBYTE; { Sound for left channel, or NULL if none } alf_RightSample : PBYTE; { Sound for right channel, or NULL if none } alf_SamplesPerSec : longword; { Replay speed; if > 0, this overrides alf_Period } end; { ADTM_START, ADTM_PAUSE, ADTM_STOP, ADTM_LOCATE } padtStart = ^tadtStart; tadtStart = record MethodID, asa_Frame : longword; { Frame # to start at } end; { *************************************************************************** } var DataTypesBase : PLibrary; const DATATYPESNAME : PChar = 'datatypes.library'; function ObtainDataTypeA(type_ : CARDINAL location 'd0'; handle : POINTER location 'a0'; attrs : pTagItem location 'a1') : pDataType; SysCall DataTypesBase 036; function ObtainDataType(type_ : CARDINAL; handle : POINTER; attrs : array of LongWord) : pDataType; Inline; procedure ReleaseDataType(dt : pDataType location 'a0'); SysCall DataTypesBase 042; function NewDTObjectA(name : PChar location 'd0'; attrs : pTagItem location 'a0') : CARDINAL; SysCall DataTypesBase 048; function NewDTObject(name : PChar; attrs : array of LongWord) : CARDINAL; Inline; procedure DisposeDTObject(o : CARDINAL location 'a0'); SysCall DataTypesBase 054; function SetDTAttrsA(o : CARDINAL location 'a0'; win : pWindow location 'a1'; req : pRequester location 'a2'; attrs : pTagItem location 'a3') : CARDINAL; SysCall DataTypesBase 060; function SetDTAttrs(o : CARDINAL; win : pWindow; req : pRequester; attrs : array of LongWord) : CARDINAL; Inline; function GetDTAttrsA(o : CARDINAL location 'a0'; attrs : pTagItem location 'a2') : CARDINAL; SysCall DataTypesBase 066; function GetDTAttrs(o : CARDINAL; attrs : array of LongWord) : CARDINAL; Inline; function AddDTObject(win : pWindow location 'a0'; req : pRequester location 'a1'; o : CARDINAL location 'a2'; pos : LongInt location 'd0') : LongInt; SysCall DataTypesBase 072; procedure RefreshDTObjectA(o : CARDINAL location 'a0'; win : pWindow location 'a1'; req : pRequester location 'a2'; attrs : pTagItem location 'a3'); SysCall DataTypesBase 078; procedure RefreshDTObject(o : CARDINAL; win : pWindow; req : pRequester; attrs : array of LongWord); Inline; function DoAsyncLayout(o : CARDINAL location 'a0'; gpl : pgpLayout location 'a1') : CARDINAL; SysCall DataTypesBase 084; function DoDTMethodA(o : CARDINAL location 'a0'; win : pWindow location 'a1'; req : pRequester location 'a2'; msg : pLongInt location 'a3') : CARDINAL; SysCall DataTypesBase 090; function DoDTMethod(o : CARDINAL; win : pWindow; req : pRequester; msg : array of LongInt) : CARDINAL; Inline; function RemoveDTObject(win : pWindow location 'a0'; o : CARDINAL location 'a1') : LongInt; SysCall DataTypesBase 096; function GetDTMethods(o : CARDINAL location 'a0') : pCARDINAL; SysCall DataTypesBase 102; function GetDTTriggerMethods(o : CARDINAL location 'a0') : pDTMethod; SysCall DataTypesBase 108; function PrintDTObjectA(o : CARDINAL location 'a0'; w : pWindow location 'a1'; r : pRequester location 'a2'; msg : pdtPrint location 'a3') : CARDINAL; SysCall DataTypesBase 114; function ObtainDTDrawInfoA(o : CARDINAL location 'a0'; attrs : pTagItem location 'a1') : POINTER; SysCall DataTypesBase 120; function ObtainDTDrawInfo(o : CARDINAL; attrs : array of LongWord) : POINTER; Inline; function DrawDTObjectA(rp : pRastPort location 'a0'; o : CARDINAL location 'a1'; x : LongInt location 'd0'; y : LongInt location 'd1'; w : LongInt location 'd2'; h : LongInt location 'd3'; th : LongInt location 'd4'; tv : LongInt location 'd5'; attrs : pTagItem location 'a2') : LongInt; SysCall DataTypesBase 126; function DrawDTObject(rp : pRastPort; o : CARDINAL; x : LongInt; y : LongInt; w : LongInt; h : LongInt; th : LongInt; tv : LongInt; attrs : array of LongWord) : LongInt; Inline; procedure ReleaseDTDrawInfo(o : CARDINAL location 'a0'; handle : POINTER location 'a1'); SysCall DataTypesBase 132; function GetDTString(id : CARDINAL location 'd0') : pSHORTINT; SysCall DataTypesBase 138; procedure LockDataType(dt : pDataType location 'a0'); SysCall DataTypesBase 240; function FindToolNodeA(tl : pList location 'a0'; attrs : pTagItem location 'a1') : pToolNode; SysCall DataTypesBase 246; function FindToolNode(tl : pList; attrs : array of LongWord) : pToolNode; Inline; function LaunchToolA(t : pTool location 'a0'; project : pSHORTINT location 'a1'; attrs : pTagItem location 'a2') : CARDINAL; SysCall DataTypesBase 252; function LaunchTool(t : pTool; project : pSHORTINT; attrs : array of LongWord) : CARDINAL; Inline; function FindMethod(methods : CARDINAL location 'a0'; id : CARDINAL location 'a1') : pCARDINAL; SysCall DataTypesBase 258; function FindTriggerMethod(triggermethods : pDTMethod location 'a0'; command : pSHORTINT location 'a1'; method : CARDINAL location 'd0') : pDTMethod; SysCall DataTypesBase 264; function CopyDTMethods(src : CARDINAL location 'a0'; include : CARDINAL location 'a1'; exclude : CARDINAL location 'a2') : pCARDINAL; SysCall DataTypesBase 270; function CopyDTTriggerMethods(src : pDTMethod location 'a0'; include : pDTMethod location 'a1'; exclude : pDTMethod location 'a2') : pDTMethod; SysCall DataTypesBase 276; procedure FreeDTMethods(m : POINTER location 'a0'); SysCall DataTypesBase 282; function GetDTTriggerMethodDataFlags(triggermethod : CARDINAL location 'd0') : CARDINAL; SysCall DataTypesBase 288; function SaveDTObjectA(o : CARDINAL location 'a0'; win : pWindow location 'a1'; req : pRequester location 'a2'; file_ : PChar location 'a3'; mode : CARDINAL location 'd0'; saveicon : BOOLEAN location 'd1'; attrs : pTagItem location 'a4') : CARDINAL; SysCall DataTypesBase 294; function SaveDTObject(o : CARDINAL; win : pWindow; req : pRequester; file_ : PChar; mode : CARDINAL; saveicon : BOOLEAN; attrs : array of LongWord) : CARDINAL; Inline; function StartDragSelect(o : CARDINAL location 'a0') : CARDINAL; SysCall DataTypesBase 300; function DoDTDomainA(o : CARDINAL location 'a0'; win : pWindow location 'a1'; req : pRequester location 'a2'; rport : pRastPort location 'a3'; which : CARDINAL location 'd0'; domain : pIBox location 'a4'; attrs : pTagItem location 'a5') : CARDINAL; SysCall DataTypesBase 306; function DoDTDomain(o : CARDINAL; win : pWindow; req : pRequester; rport : pRastPort; which : CARDINAL; domain : pIBox; attrs : array of LongWord) : CARDINAL; Inline; function InitDatatypesLibrary : boolean; implementation function ObtainDataType(type_ : CARDINAL; handle : POINTER; attrs : array of LongWord) : pDataType; Inline; begin ObtainDataType:=ObtainDataTypeA(type_, handle, @attrs); end; function NewDTObject(name : PChar; attrs : array of LongWord) : CARDINAL; Inline; begin NewDTObject:=NewDTObjectA(name, @attrs); end; function SetDTAttrs(o : CARDINAL; win : pWindow; req : pRequester; attrs : array of LongWord) : CARDINAL; Inline; begin SetDTAttrs:=SetDTAttrsA(o, win, req, @attrs); end; function GetDTAttrs(o : CARDINAL; attrs : array of LongWord) : CARDINAL; Inline; begin GetDTAttrs:=GetDTAttrsA(o, @attrs); end; function DoDTMethod(o : CARDINAL; win : pWindow; req : pRequester; msg : array of LongInt) : CARDINAL; Inline; begin DoDTMethod:=DoDTMethodA(o, win, req, @msg); end; procedure RefreshDTObject(o : CARDINAL; win : pWindow; req : pRequester; attrs : array of LongWord); Inline; begin RefreshDTObjectA(o, win, req, @attrs); end; function ObtainDTDrawInfo(o : CARDINAL; attrs : array of LongWord) : POINTER; Inline; begin ObtainDTDrawInfo:=ObtainDTDrawInfoA(o, @attrs); end; function DrawDTObject(rp : pRastPort; o : CARDINAL; x : LongInt; y : LongInt; w : LongInt; h : LongInt; th : LongInt; tv : LongInt; attrs : array of LongWord) : LongInt; Inline; begin DrawDTObject:=DrawDTObjectA(rp, o, x, y, w, h, th, tv, @attrs); end; function FindToolNode(tl : pList; attrs : array of LongWord) : pToolNode; Inline; begin FindToolNode:=FindToolNodeA(tl, @attrs); end; function LaunchTool(t : pTool; project : pSHORTINT; attrs : array of LongWord) : CARDINAL; Inline; begin LaunchTool:=LaunchToolA(t, project, @attrs); end; function SaveDTObject(o : CARDINAL; win : pWindow; req : pRequester; file_ : PChar; mode : CARDINAL; saveicon : BOOLEAN; attrs : array of LongWord) : CARDINAL; Inline; begin SaveDTObject:=SaveDTObjectA(o, win, req, file_, mode, saveicon, @attrs); end; function DoDTDomain(o : CARDINAL; win : pWindow; req : pRequester; rport : pRastPort; which : CARDINAL; domain : pIBox; attrs : array of LongWord) : CARDINAL; Inline; begin DoDTDomain:=DoDTDomainA(o, win, req, rport, which, domain, @attrs); end; const { Change VERSION and LIBVERSION to proper values } VERSION : string[2] = '50'; LIBVERSION : longword = 50; var datatypes_exit : Pointer; procedure CloseDatatypesLibrary; begin ExitProc := datatypes_exit; if DatatypesBase <> nil then begin CloseLibrary(PLibrary(DatatypesBase)); DatatypesBase := nil; end; end; function InitDatatypesLibrary : boolean; begin DatatypesBase := nil; DatatypesBase := OpenLibrary(DATATYPESNAME,LIBVERSION); if DatatypesBase <> nil then begin datatypes_exit := ExitProc; ExitProc := @CloseDatatypesLibrary; InitDatatypesLibrary:=True; end else begin InitDatatypesLibrary:=False; end; end; end. { UNIT DATATYPES }