home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Resources.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  8.9 KB  |  339 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Resources.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Resources;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __RESOURCES__}
  27. {$SETC __RESOURCES__ := 1}
  28.  
  29. {$I+}
  30. {$SETC ResourcesIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43. {$IFC UNDEFINED __FILES__}
  44. {$I Files.p}
  45. {$ENDC}
  46. {    OSUtils.p                                                    }
  47. {        Memory.p                                                }
  48.  
  49. {$PUSH}
  50. {$ALIGN MAC68K}
  51. {$LibExport+}
  52.  
  53. CONST
  54.     resSysHeap                    = 64;                            {System or application heap?}
  55.     resPurgeable                = 32;                            {Purgeable resource?}
  56.     resLocked                    = 16;                            {Load it in locked?}
  57.     resProtected                = 8;                            {Protected?}
  58.     resPreload                    = 4;                            {Load in on OpenResFile?}
  59.     resChanged                    = 2;                            {Resource changed?}
  60.     mapReadOnly                    = 128;                            {Resource file read-only}
  61.     mapCompact                    = 64;                            {Compact resource file}
  62.     mapChanged                    = 32;                            {Write map out at update}
  63.     kResFileNotOpened            = -1;                            {ref num return as error when opening a resource file}
  64.     kSystemResFile                = 0;                            {this is the default ref num to the system file}
  65.  
  66. TYPE
  67.     {
  68.         ResErrProcPtr uses register based parameters on the 68k and cannot
  69.         be written in or called from a high-level language without the help of
  70.         mixed mode or assembly glue.
  71.  
  72.         In:
  73.          => thErr           D0.W
  74.     }
  75.     ResErrProcPtr = ProcPtr;  { PROCEDURE ResErr(thErr: OSErr); }
  76.     ResErrUPP = UniversalProcPtr;
  77.  
  78. CONST
  79.     uppResErrProcInfo = $00001002; { Register PROCEDURE (2 bytes in D0); }
  80.  
  81. FUNCTION NewResErrProc(userRoutine: ResErrProcPtr): ResErrUPP;
  82.     {$IFC NOT GENERATINGCFM }
  83.     INLINE $2E9F;
  84.     {$ENDC}
  85.  
  86. PROCEDURE CallResErrProc(thErr: OSErr; userRoutine: ResErrUPP);
  87.     {$IFC NOT GENERATINGCFM}
  88.     {To be implemented:  Glue to move parameters into registers.}
  89.     {$ENDC}
  90.  
  91. FUNCTION InitResources: INTEGER;
  92.     {$IFC NOT GENERATINGCFM}
  93.     INLINE $A995;
  94.     {$ENDC}
  95. PROCEDURE RsrcZoneInit;
  96.     {$IFC NOT GENERATINGCFM}
  97.     INLINE $A996;
  98.     {$ENDC}
  99. PROCEDURE CloseResFile(refNum: INTEGER);
  100.     {$IFC NOT GENERATINGCFM}
  101.     INLINE $A99A;
  102.     {$ENDC}
  103. FUNCTION ResError: INTEGER;
  104.     {$IFC NOT GENERATINGCFM}
  105.     INLINE $A9AF;
  106.     {$ENDC}
  107. FUNCTION CurResFile: INTEGER;
  108.     {$IFC NOT GENERATINGCFM}
  109.     INLINE $A994;
  110.     {$ENDC}
  111. FUNCTION HomeResFile(theResource: Handle): INTEGER;
  112.     {$IFC NOT GENERATINGCFM}
  113.     INLINE $A9A4;
  114.     {$ENDC}
  115. PROCEDURE CreateResFile(fileName: ConstStr255Param);
  116.     {$IFC NOT GENERATINGCFM}
  117.     INLINE $A9B1;
  118.     {$ENDC}
  119. FUNCTION OpenResFile(fileName: ConstStr255Param): INTEGER;
  120.     {$IFC NOT GENERATINGCFM}
  121.     INLINE $A997;
  122.     {$ENDC}
  123. PROCEDURE UseResFile(refNum: INTEGER);
  124.     {$IFC NOT GENERATINGCFM}
  125.     INLINE $A998;
  126.     {$ENDC}
  127. FUNCTION CountTypes: INTEGER;
  128.     {$IFC NOT GENERATINGCFM}
  129.     INLINE $A99E;
  130.     {$ENDC}
  131. FUNCTION Count1Types: INTEGER;
  132.     {$IFC NOT GENERATINGCFM}
  133.     INLINE $A81C;
  134.     {$ENDC}
  135. PROCEDURE GetIndType(VAR theType: ResType; index: INTEGER);
  136.     {$IFC NOT GENERATINGCFM}
  137.     INLINE $A99F;
  138.     {$ENDC}
  139. PROCEDURE Get1IndType(VAR theType: ResType; index: INTEGER);
  140.     {$IFC NOT GENERATINGCFM}
  141.     INLINE $A80F;
  142.     {$ENDC}
  143. PROCEDURE SetResLoad(load: BOOLEAN);
  144.     {$IFC NOT GENERATINGCFM}
  145.     INLINE $A99B;
  146.     {$ENDC}
  147. FUNCTION CountResources(theType: ResType): INTEGER;
  148.     {$IFC NOT GENERATINGCFM}
  149.     INLINE $A99C;
  150.     {$ENDC}
  151. FUNCTION Count1Resources(theType: ResType): INTEGER;
  152.     {$IFC NOT GENERATINGCFM}
  153.     INLINE $A80D;
  154.     {$ENDC}
  155. FUNCTION GetIndResource(theType: ResType; index: INTEGER): Handle;
  156.     {$IFC NOT GENERATINGCFM}
  157.     INLINE $A99D;
  158.     {$ENDC}
  159. FUNCTION Get1IndResource(theType: ResType; index: INTEGER): Handle;
  160.     {$IFC NOT GENERATINGCFM}
  161.     INLINE $A80E;
  162.     {$ENDC}
  163. FUNCTION GetResource(theType: ResType; theID: INTEGER): Handle;
  164.     {$IFC NOT GENERATINGCFM}
  165.     INLINE $A9A0;
  166.     {$ENDC}
  167. FUNCTION Get1Resource(theType: ResType; theID: INTEGER): Handle;
  168.     {$IFC NOT GENERATINGCFM}
  169.     INLINE $A81F;
  170.     {$ENDC}
  171. FUNCTION GetNamedResource(theType: ResType; name: ConstStr255Param): Handle;
  172.     {$IFC NOT GENERATINGCFM}
  173.     INLINE $A9A1;
  174.     {$ENDC}
  175. FUNCTION Get1NamedResource(theType: ResType; name: ConstStr255Param): Handle;
  176.     {$IFC NOT GENERATINGCFM}
  177.     INLINE $A820;
  178.     {$ENDC}
  179. PROCEDURE LoadResource(theResource: Handle);
  180.     {$IFC NOT GENERATINGCFM}
  181.     INLINE $A9A2;
  182.     {$ENDC}
  183. PROCEDURE ReleaseResource(theResource: Handle);
  184.     {$IFC NOT GENERATINGCFM}
  185.     INLINE $A9A3;
  186.     {$ENDC}
  187. PROCEDURE DetachResource(theResource: Handle);
  188.     {$IFC NOT GENERATINGCFM}
  189.     INLINE $A992;
  190.     {$ENDC}
  191. FUNCTION UniqueID(theType: ResType): INTEGER;
  192.     {$IFC NOT GENERATINGCFM}
  193.     INLINE $A9C1;
  194.     {$ENDC}
  195. FUNCTION Unique1ID(theType: ResType): INTEGER;
  196.     {$IFC NOT GENERATINGCFM}
  197.     INLINE $A810;
  198.     {$ENDC}
  199. FUNCTION GetResAttrs(theResource: Handle): INTEGER;
  200.     {$IFC NOT GENERATINGCFM}
  201.     INLINE $A9A6;
  202.     {$ENDC}
  203. PROCEDURE GetResInfo(theResource: Handle; VAR theID: INTEGER; VAR theType: ResType; VAR name: Str255);
  204.     {$IFC NOT GENERATINGCFM}
  205.     INLINE $A9A8;
  206.     {$ENDC}
  207. PROCEDURE SetResInfo(theResource: Handle; theID: INTEGER; name: ConstStr255Param);
  208.     {$IFC NOT GENERATINGCFM}
  209.     INLINE $A9A9;
  210.     {$ENDC}
  211. PROCEDURE AddResource(theData: Handle; theType: ResType; theID: INTEGER; name: ConstStr255Param);
  212.     {$IFC NOT GENERATINGCFM}
  213.     INLINE $A9AB;
  214.     {$ENDC}
  215. FUNCTION GetResourceSizeOnDisk(theResource: Handle): LONGINT;
  216.     {$IFC NOT GENERATINGCFM}
  217.     INLINE $A9A5;
  218.     {$ENDC}
  219. FUNCTION GetMaxResourceSize(theResource: Handle): LONGINT;
  220.     {$IFC NOT GENERATINGCFM}
  221.     INLINE $A821;
  222.     {$ENDC}
  223. FUNCTION RsrcMapEntry(theResource: Handle): LONGINT;
  224.     {$IFC NOT GENERATINGCFM}
  225.     INLINE $A9C5;
  226.     {$ENDC}
  227. PROCEDURE SetResAttrs(theResource: Handle; attrs: INTEGER);
  228.     {$IFC NOT GENERATINGCFM}
  229.     INLINE $A9A7;
  230.     {$ENDC}
  231. PROCEDURE ChangedResource(theResource: Handle);
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $A9AA;
  234.     {$ENDC}
  235. PROCEDURE RemoveResource(theResource: Handle);
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $A9AD;
  238.     {$ENDC}
  239. PROCEDURE UpdateResFile(refNum: INTEGER);
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $A999;
  242.     {$ENDC}
  243. PROCEDURE WriteResource(theResource: Handle);
  244.     {$IFC NOT GENERATINGCFM}
  245.     INLINE $A9B0;
  246.     {$ENDC}
  247. PROCEDURE SetResPurge(install: BOOLEAN);
  248.     {$IFC NOT GENERATINGCFM}
  249.     INLINE $A993;
  250.     {$ENDC}
  251. FUNCTION GetResFileAttrs(refNum: INTEGER): INTEGER;
  252.     {$IFC NOT GENERATINGCFM}
  253.     INLINE $A9F6;
  254.     {$ENDC}
  255. PROCEDURE SetResFileAttrs(refNum: INTEGER; attrs: INTEGER);
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $A9F7;
  258.     {$ENDC}
  259. FUNCTION OpenRFPerm(fileName: ConstStr255Param; vRefNum: INTEGER; permission: ByteParameter): INTEGER;
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $A9C4;
  262.     {$ENDC}
  263. FUNCTION RGetResource(theType: ResType; theID: INTEGER): Handle;
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $A80C;
  266.     {$ENDC}
  267. {$IFC SystemSevenOrLater }
  268. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  269.     {$IFC NOT GENERATINGCFM}
  270.     INLINE $A81A;
  271.     {$ENDC}
  272. {$ELSEC}
  273. FUNCTION HOpenResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param; permission: ByteParameter): INTEGER;
  274. {$ENDC}
  275. {$IFC SystemSevenOrLater }
  276. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $A81B;
  279.     {$ENDC}
  280. {$ELSEC}
  281. PROCEDURE HCreateResFile(vRefNum: INTEGER; dirID: LONGINT; fileName: ConstStr255Param);
  282. {$ENDC}
  283. FUNCTION FSpOpenResFile({CONST}VAR spec: FSSpec; permission: ByteParameter): INTEGER;
  284.     {$IFC NOT GENERATINGCFM}
  285.     INLINE $700D, $AA52;
  286.     {$ENDC}
  287. PROCEDURE FSpCreateResFile({CONST}VAR spec: FSSpec; creator: OSType; fileType: OSType; scriptTag: ScriptCode);
  288.     {$IFC NOT GENERATINGCFM}
  289.     INLINE $700E, $AA52;
  290.     {$ENDC}
  291. {  partial resource calls  }
  292. PROCEDURE ReadPartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  293.     {$IFC NOT GENERATINGCFM}
  294.     INLINE $7001, $A822;
  295.     {$ENDC}
  296. PROCEDURE WritePartialResource(theResource: Handle; offset: LONGINT; buffer: UNIV Ptr; count: LONGINT);
  297.     {$IFC NOT GENERATINGCFM}
  298.     INLINE $7002, $A822;
  299.     {$ENDC}
  300. PROCEDURE SetResourceSize(theResource: Handle; newSize: LONGINT);
  301.     {$IFC NOT GENERATINGCFM}
  302.     INLINE $7003, $A822;
  303.     {$ENDC}
  304. FUNCTION GetNextFOND(fondHandle: Handle): Handle;
  305.     {$IFC NOT GENERATINGCFM}
  306.     INLINE $700A, $A822;
  307.     {$ENDC}
  308. { Use TempInsertROMMap to force the ROM resource map to be
  309.    inserted into the chain in front of the system. Note that
  310.    this call is only temporary - the modified resource chain
  311.    is only used for the next call to the resource manager.
  312.    See IM IV 19 for more information. }
  313. PROCEDURE TempInsertROMMap(tempResLoad: BOOLEAN);
  314. {$IFC OLDROUTINENAMES }
  315. FUNCTION SizeResource(theResource: Handle): LONGINT;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $A9A5;
  318.     {$ENDC}
  319. FUNCTION MaxSizeRsrc(theResource: Handle): LONGINT;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $A821;
  322.     {$ENDC}
  323. PROCEDURE RmveResource(theResource: Handle);
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $A9AD;
  326.     {$ENDC}
  327. {$ENDC}
  328.  
  329. {$ALIGN RESET}
  330. {$POP}
  331.  
  332. {$SETC UsingIncludes := ResourcesIncludes}
  333.  
  334. {$ENDC} {__RESOURCES__}
  335.  
  336. {$IFC NOT UsingIncludes}
  337.  END.
  338. {$ENDC}
  339.