home *** CD-ROM | disk | FTP | other *** search
/ HyperLib 1997 Winter - Disc 1 / HYPERLIB-1997-Winter-CD1.ISO.7z / HYPERLIB-1997-Winter-CD1.ISO / 第１特集Plug-in / Photoshop / Plug-in_Kit_2.5.1.sit / Plug-in_Kit_2.5.1 / Code / #temp.h.out# next >
Text File  |  1994-03-23  |  11KB  |  379 lines
  1. /*
  2.     File:        temp.h.c
  3.  
  4.     Copyright:    ｩ 1984-1993 by Apple Computer, Inc., all rights reserved.
  5.  
  6.     WARNING
  7. TestAbortProcProcUPP,
  8.         kPascalStackBased
  9.          | RESULT_SIZE(SIZE_CODE(sizeof(Boolean))));
  10. ProgressProcProcUPP,
  11.         kPascalStackBased
  12.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(done)))
  13.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(total))),
  14. HostProcProcUPP,
  15.         kPascalStackBased
  16.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(selector)))
  17.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(data))),
  18.  
  19.             #error "Result types larger than 4 bytes are not supported."
  20.         #endif
  21.     #endif
  22.     long    private_result;
  23.     static UniversalProcPtr*    private_trapVector = nil;
  24.  
  25.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  26.  
  27.     private_result = CallUniversalProc(SpaceProcProcUPP,
  28.         kPascalStackBased
  29.          | RESULT_SIZE(SIZE_CODE(sizeof(int32))));
  30.     return *(((int32*)&private_result) + RESULT_OFFSET(int32));
  31. }
  32.  
  33. UniversalProcPtr NewPIHandleProcProcUPP;
  34.  
  35. pascal Handle NewPIHandleProcProc(int32 size)
  36. {
  37.     #ifdef applec
  38.         #if sizeof(Handle) > 4
  39.             #error "Result types larger than 4 bytes are not supported."
  40.         #endif
  41.     #endif
  42.     long    private_result;
  43.     static UniversalProcPtr*    private_trapVector = nil;
  44.  
  45.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  46.  
  47.     private_result = CallUniversalProc(NewPIHandleProcProcUPP,
  48.         kPascalStackBased
  49.          | RESULT_SIZE(SIZE_CODE(sizeof(Handle)))
  50.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(size))),
  51.         size);
  52.     return *(((Handle*)&private_result) + RESULT_OFFSET(Handle));
  53. }
  54.  
  55. UniversalProcPtr DisposePIHandleProcProcUPP;
  56.  
  57. pascal void DisposePIHandleProcProc(Handle h)
  58. {
  59.     static UniversalProcPtr*    private_trapVector = nil;
  60.  
  61.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  62.  
  63.     (void)CallUniversalProc(DisposePIHandleProcProcUPP,
  64.         kPascalStackBased
  65.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(h))),
  66.         h);
  67. }
  68.  
  69. UniversalProcPtr GetPIHandleSizeProcProcUPP;
  70.  
  71. pascal int32 GetPIHandleSizeProcProc(Handle h)
  72. {
  73.     #ifdef applec
  74.         #if sizeof(int32) > 4
  75.             #error "Result types larger than 4 bytes are not supported."
  76.         #endif
  77.     #endif
  78.     long    private_result;
  79.     static UniversalProcPtr*    private_trapVector = nil;
  80.  
  81.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  82.  
  83.     private_result = CallUniversalProc(GetPIHandleSizeProcProcUPP,
  84.         kPascalStackBased
  85.          | RESULT_SIZE(SIZE_CODE(sizeof(int32)))
  86.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(h))),
  87.         h);
  88.     return *(((int32*)&private_result) + RESULT_OFFSET(int32));
  89. }
  90.  
  91. UniversalProcPtr SetPIHandleSizeProcProcUPP;
  92.  
  93. pascal OSErr SetPIHandleSizeProcProc(Handle h, int32 newSize)
  94. {
  95.     #ifdef applec
  96.         #if sizeof(OSErr) > 4
  97.             #error "Result types larger than 4 bytes are not supported."
  98.         #endif
  99.     #endif
  100.     long    private_result;
  101.     static UniversalProcPtr*    private_trapVector = nil;
  102.  
  103.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  104.  
  105.     private_result = CallUniversalProc(SetPIHandleSizeProcProcUPP,
  106.         kPascalStackBased
  107.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  108.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(h)))
  109.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(newSize))),
  110.         h,
  111.         newSize);
  112.     return *(((OSErr*)&private_result) + RESULT_OFFSET(OSErr));
  113. }
  114.  
  115. UniversalProcPtr LockPIHandleProcProcUPP;
  116.  
  117. pascal Ptr LockPIHandleProcProc(Handle h, Boolean moveHigh)
  118. {
  119.     #ifdef applec
  120.         #if sizeof(Ptr) > 4
  121.             #error "Result types larger than 4 bytes are not supported."
  122.         #endif
  123.     #endif
  124.     long    private_result;
  125.     static UniversalProcPtr*    private_trapVector = nil;
  126.  
  127.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  128.  
  129.     private_result = CallUniversalProc(LockPIHandleProcProcUPP,
  130.         kPascalStackBased
  131.          | RESULT_SIZE(SIZE_CODE(sizeof(Ptr)))
  132.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(h)))
  133.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(moveHigh))),
  134.         h,
  135.         moveHigh);
  136.     return *(((Ptr*)&private_result) + RESULT_OFFSET(Ptr));
  137. }
  138.  
  139. UniversalProcPtr UnlockPIHandleProcProcUPP;
  140.  
  141. pascal void UnlockPIHandleProcProc(Handle h)
  142. {
  143.     static UniversalProcPtr*    private_trapVector = nil;
  144.  
  145.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  146.  
  147.     (void)CallUniversalProc(UnlockPIHandleProcProcUPP,
  148.         kPascalStackBased
  149.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(h))),
  150.         h);
  151. }
  152.  
  153. UniversalProcPtr AllocateBufferProcProcUPP;
  154.  
  155. pascal OSErr AllocateBufferProcProc(int32 size, BufferID *bufferID)
  156. {
  157.     #ifdef applec
  158.         #if sizeof(OSErr) > 4
  159.             #error "Result types larger than 4 bytes are not supported."
  160.         #endif
  161.     #endif
  162.     long    private_result;
  163.     static UniversalProcPtr*    private_trapVector = nil;
  164.  
  165.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  166.  
  167.     private_result = CallUniversalProc(AllocateBufferProcProcUPP,
  168.         kPascalStackBased
  169.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  170.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(size)))
  171.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(bufferID))),
  172.         size,
  173.         bufferID);
  174.     return *(((OSErr*)&private_result) + RESULT_OFFSET(OSErr));
  175. }
  176.  
  177. UniversalProcPtr LockBufferProcProcUPP;
  178.  
  179. pascal Ptr LockBufferProcProc(BufferID bufferID, Boolean moveHigh)
  180. {
  181.     #ifdef applec
  182.         #if sizeof(Ptr) > 4
  183.             #error "Result types larger than 4 bytes are not supported."
  184.         #endif
  185.     #endif
  186.     long    private_result;
  187.     static UniversalProcPtr*    private_trapVector = nil;
  188.  
  189.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  190.  
  191.     private_result = CallUniversalProc(LockBufferProcProcUPP,
  192.         kPascalStackBased
  193.          | RESULT_SIZE(SIZE_CODE(sizeof(Ptr)))
  194.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(bufferID)))
  195.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(moveHigh))),
  196.         bufferID,
  197.         moveHigh);
  198.     return *(((Ptr*)&private_result) + RESULT_OFFSET(Ptr));
  199. }
  200.  
  201. UniversalProcPtr UnlockBufferProcProcUPP;
  202.  
  203. pascal void UnlockBufferProcProc(BufferID bufferID)
  204. {
  205.     static UniversalProcPtr*    private_trapVector = nil;
  206.  
  207.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  208.  
  209.     (void)CallUniversalProc(UnlockBufferProcProcUPP,
  210.         kPascalStackBased
  211.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(bufferID))),
  212.         bufferID);
  213. }
  214.  
  215. UniversalProcPtr FreeBufferProcProcUPP;
  216.  
  217. pascal void FreeBufferProcProc(BufferID bufferID)
  218. {
  219.     static UniversalProcPtr*    private_trapVector = nil;
  220.  
  221.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  222.  
  223.     (void)CallUniversalProc(FreeBufferProcProcUPP,
  224.         kPascalStackBased
  225.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(bufferID))),
  226.         bufferID);
  227. }
  228.  
  229. UniversalProcPtr BufferSpaceProcProcUPP;
  230.  
  231. pascal int32 BufferSpaceProcProc(void)
  232. {
  233.     #ifdef applec
  234.         #if sizeof(int32) > 4
  235.             #error "Result types larger than 4 bytes are not supported."
  236.         #endif
  237.     #endif
  238.     long    private_result;
  239.     static UniversalProcPtr*    private_trapVector = nil;
  240.  
  241.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  242.  
  243.     private_result = CallUniversalProc(BufferSpaceProcProcUPP,
  244.         kPascalStackBased
  245.          | RESULT_SIZE(SIZE_CODE(sizeof(int32))));
  246.     return *(((int32*)&private_result) + RESULT_OFFSET(int32));
  247. }
  248.  
  249. UniversalProcPtr CountPIResourcesProcProcUPP;
  250.  
  251. pascal int16 CountPIResourcesProcProc(ResType type)
  252. {
  253.     #ifdef applec
  254.         #if sizeof(int16) > 4
  255.             #error "Result types larger than 4 bytes are not supported."
  256.         #endif
  257.     #endif
  258.     long    private_result;
  259.     static UniversalProcPtr*    private_trapVector = nil;
  260.  
  261.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  262.  
  263.     private_result = CallUniversalProc(CountPIResourcesProcProcUPP,
  264.         kPascalStackBased
  265.          | RESULT_SIZE(SIZE_CODE(sizeof(int16)))
  266.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(type))),
  267.         type);
  268.     return *(((int16*)&private_result) + RESULT_OFFSET(int16));
  269. }
  270.  
  271. UniversalProcPtr GetPIResourceProcProcUPP;
  272.  
  273. pascal Handle GetPIResourceProcProc(ResType type, int16 index)
  274. {
  275.     #ifdef applec
  276.         #if sizeof(Handle) > 4
  277.             #error "Result types larger than 4 bytes are not supported."
  278.         #endif
  279.     #endif
  280.     long    private_result;
  281.     static UniversalProcPtr*    private_trapVector = nil;
  282.  
  283.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  284.  
  285.     private_result = CallUniversalProc(GetPIResourceProcProcUPP,
  286.         kPascalStackBased
  287.          | RESULT_SIZE(SIZE_CODE(sizeof(Handle)))
  288.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(type)))
  289.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(index))),
  290.         type,
  291.         index);
  292.     return *(((Handle*)&private_result) + RESULT_OFFSET(Handle));
  293. }
  294.  
  295. UniversalProcPtr DeletePIResourceProcProcUPP;
  296.  
  297. pascal void DeletePIResourceProcProc(ResType type, int16 index)
  298. {
  299.     static UniversalProcPtr*    private_trapVector = nil;
  300.  
  301.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  302.  
  303.     (void)CallUniversalProc(DeletePIResourceProcProcUPP,
  304.         kPascalStackBased
  305.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(type)))
  306.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(index))),
  307.         type,
  308.         index);
  309. }
  310.  
  311. UniversalProcPtr AddPIResourceProcProcUPP;
  312.  
  313. pascal OSErr AddPIResourceProcProc(ResType type, Handle data)
  314. {
  315.     #ifdef applec
  316.         #if sizeof(OSErr) > 4
  317.             #error "Result types larger than 4 bytes are not supported."
  318.         #endif
  319.     #endif
  320.     long    private_result;
  321.     static UniversalProcPtr*    private_trapVector = nil;
  322.  
  323.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  324.  
  325.     private_result = CallUniversalProc(AddPIResourceProcProcUPP,
  326.         kPascalStackBased
  327.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  328.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(type)))
  329.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(data))),
  330.         type,
  331.         data);
  332.     return *(((OSErr*)&private_result) + RESULT_OFFSET(OSErr));
  333. }
  334.  
  335. UniversalProcPtr ProcessEventProcProcUPP;
  336.  
  337. pascal void ProcessEventProcProc(void *event)
  338. {
  339.     static UniversalProcPtr*    private_trapVector = nil;
  340.  
  341.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  342.  
  343.     (void)CallUniversalProc(ProcessEventProcProcUPP,
  344.         kPascalStackBased
  345.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(event))),
  346.         event);
  347. }
  348.  
  349. UniversalProcPtr DisplayPixelsProcProcUPP;
  350.  
  351. pascal OSErr DisplayPixelsProcProc(const PSPixelMap *source, const VRect *srcRect, int32 dstRow, int32 dstCol, unsigned32 platformContext)
  352. {
  353.     #ifdef applec
  354.         #if sizeof(OSErr) > 4
  355.             #error "Result types larger than 4 bytes are not supported."
  356.         #endif
  357.     #endif
  358.     long    private_result;
  359.     static UniversalProcPtr*    private_trapVector = nil;
  360.  
  361.     if (!private_trapVector) private_trapVector = GetTrapVector(0x0000);
  362.  
  363.     private_result = CallUniversalProc(DisplayPixelsProcProcUPP,
  364.         kPascalStackBased
  365.          | RESULT_SIZE(SIZE_CODE(sizeof(OSErr)))
  366.          | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(source)))
  367.          | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(srcRect)))
  368.          | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(dstRow)))
  369.          | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(dstCol)))
  370.          | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(platformContext))),
  371.         source,
  372.         srcRect,
  373.         dstRow,
  374.         dstCol,
  375.         platformContext);
  376.     return *(((OSErr*)&private_result) + RESULT_OFFSET(OSErr));
  377. }
  378.  
  379.