home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Graphics / PPT / include / ppcpragmas / pptsupp_pragmas.h
C/C++ Source or Header  |  1998-05-24  |  27KB  |  715 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_PPTSUPP_H
  4. #define _PPCPRAGMA_PPTSUPP_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__PPTSUPP_H
  7. #include <powerup/ppcinline/pptsupp.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef PPTSUPP_BASE_NAME
  24. #define PPTSUPP_BASE_NAME PPTBase
  25. #endif /* !PPTSUPP_BASE_NAME */
  26.  
  27. #define AddExtension(frame, name, data, len, flags)     _AddExtension(PPTSUPP_BASE_NAME, frame, name, data, len, flags)
  28.  
  29. static __inline  PERROR
  30. _AddExtension(void *PPTBase, FRAME *frame, STRPTR name, APTR data, ULONG len, ULONG flags)
  31. {
  32. struct Caos     MyCaos;
  33.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  34. //      MyCaos.M68kStart        =       NULL;
  35. //      MyCaos.M68kSize         =       0;
  36.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  37. //      MyCaos.PPCStart         =       NULL;
  38. //      MyCaos.PPCSize          =       0;
  39.         MyCaos.a0               =(ULONG) frame;
  40.         MyCaos.a1               =(ULONG) name;
  41.         MyCaos.a2               =(ULONG) data;
  42.         MyCaos.d0               =(ULONG) len;
  43.         MyCaos.d1               =(ULONG) flags;
  44.         MyCaos.caos_Un.Offset   =       (-210);
  45.         MyCaos.a6               =(ULONG) PPTBase;       
  46.         return(( PERROR)PPCCallOS(&MyCaos));
  47. }
  48.  
  49. #define AskReqA(frame, objectlist)      _AskReqA(PPTSUPP_BASE_NAME, frame, objectlist)
  50.  
  51. static __inline  int
  52. _AskReqA(void *PPTBase, FRAME *frame, struct TagItem *objectlist)
  53. {
  54. struct Caos     MyCaos;
  55.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  56. //      MyCaos.M68kStart        =       NULL;
  57. //      MyCaos.M68kSize         =       0;
  58.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  59. //      MyCaos.PPCStart         =       NULL;
  60. //      MyCaos.PPCSize          =       0;
  61.         MyCaos.a0               =(ULONG) frame;
  62.         MyCaos.a1               =(ULONG) objectlist;
  63.         MyCaos.caos_Un.Offset   =       (-150);
  64.         MyCaos.a6               =(ULONG) PPTBase;       
  65.         return(( int)PPCCallOS(&MyCaos));
  66. }
  67.  
  68. #ifndef NO_PPCINLINE_STDARG
  69. #define AskReq(a0, tags...) \
  70.         ({ULONG _tags[] = { tags }; AskReqA((a0), (struct TagItem *)_tags);})
  71. #endif /* !NO_PPCINLINE_STDARG */
  72.  
  73. #define ClearProgress(frame)    _ClearProgress(PPTSUPP_BASE_NAME, frame)
  74.  
  75. static __inline  VOID
  76. _ClearProgress(void *PPTBase, FRAME *frame)
  77. {
  78. struct Caos     MyCaos;
  79.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  80. //      MyCaos.M68kStart        =       NULL;
  81. //      MyCaos.M68kSize         =       0;
  82.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  83. //      MyCaos.PPCStart         =       NULL;
  84. //      MyCaos.PPCSize          =       0;
  85.         MyCaos.a0               =(ULONG) frame;
  86.         MyCaos.caos_Un.Offset   =       (-132);
  87.         MyCaos.a6               =(ULONG) PPTBase;       
  88.         (VOID)PPCCallOS(&MyCaos);
  89. }
  90.  
  91. #define CopyFrameData(src, dest, flags) _CopyFrameData(PPTSUPP_BASE_NAME, src, dest, flags)
  92.  
  93. static __inline  PERROR
  94. _CopyFrameData(void *PPTBase, FRAME *src, FRAME *dest, ULONG flags)
  95. {
  96. struct Caos     MyCaos;
  97.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  98. //      MyCaos.M68kStart        =       NULL;
  99. //      MyCaos.M68kSize         =       0;
  100.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  101. //      MyCaos.PPCStart         =       NULL;
  102. //      MyCaos.PPCSize          =       0;
  103.         MyCaos.a0               =(ULONG) src;
  104.         MyCaos.a1               =(ULONG) dest;
  105.         MyCaos.d0               =(ULONG) flags;
  106.         MyCaos.caos_Un.Offset   =       (-246);
  107.         MyCaos.a6               =(ULONG) PPTBase;       
  108.         return(( PERROR)PPCCallOS(&MyCaos));
  109. }
  110.  
  111. #define DupFrame(frame, flags)  _DupFrame(PPTSUPP_BASE_NAME, frame, flags)
  112.  
  113. static __inline  FRAME *
  114. _DupFrame(void *PPTBase, FRAME *frame, ULONG flags)
  115. {
  116. struct Caos     MyCaos;
  117.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  118. //      MyCaos.M68kStart        =       NULL;
  119. //      MyCaos.M68kSize         =       0;
  120.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  121. //      MyCaos.PPCStart         =       NULL;
  122. //      MyCaos.PPCSize          =       0;
  123.         MyCaos.a0               =(ULONG) frame;
  124.         MyCaos.d0               =(ULONG) flags;
  125.         MyCaos.caos_Un.Offset   =       (-54);
  126.         MyCaos.a6               =(ULONG) PPTBase;       
  127.         return(( FRAME *)PPCCallOS(&MyCaos));
  128. }
  129.  
  130. #define FindExtension(frame, name)      _FindExtension(PPTSUPP_BASE_NAME, frame, name)
  131.  
  132. static __inline  struct Extension *
  133. _FindExtension(void *PPTBase, FRAME *frame, STRPTR name)
  134. {
  135. struct Caos     MyCaos;
  136.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  137. //      MyCaos.M68kStart        =       NULL;
  138. //      MyCaos.M68kSize         =       0;
  139.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  140. //      MyCaos.PPCStart         =       NULL;
  141. //      MyCaos.PPCSize          =       0;
  142.         MyCaos.a0               =(ULONG) frame;
  143.         MyCaos.a1               =(ULONG) name;
  144.         MyCaos.caos_Un.Offset   =       (-216);
  145.         MyCaos.a6               =(ULONG) PPTBase;       
  146.         return(( struct Extension *)PPCCallOS(&MyCaos));
  147. }
  148.  
  149. #define FindFrame(id)   _FindFrame(PPTSUPP_BASE_NAME, id)
  150.  
  151. static __inline  FRAME *
  152. _FindFrame(void *PPTBase, ULONG id)
  153. {
  154. struct Caos     MyCaos;
  155.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  156. //      MyCaos.M68kStart        =       NULL;
  157. //      MyCaos.M68kSize         =       0;
  158.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  159. //      MyCaos.PPCStart         =       NULL;
  160. //      MyCaos.PPCSize          =       0;
  161.         MyCaos.d0               =(ULONG) id;
  162.         MyCaos.caos_Un.Offset   =       (-60);
  163.         MyCaos.a6               =(ULONG) PPTBase;       
  164.         return(( FRAME *)PPCCallOS(&MyCaos));
  165. }
  166.  
  167. #define FinishProgress(frame)   _FinishProgress(PPTSUPP_BASE_NAME, frame)
  168.  
  169. static __inline  VOID
  170. _FinishProgress(void *PPTBase, FRAME *frame)
  171. {
  172. struct Caos     MyCaos;
  173.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  174. //      MyCaos.M68kStart        =       NULL;
  175. //      MyCaos.M68kSize         =       0;
  176.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  177. //      MyCaos.PPCStart         =       NULL;
  178. //      MyCaos.PPCSize          =       0;
  179.         MyCaos.a0               =(ULONG) frame;
  180.         MyCaos.caos_Un.Offset   =       (-126);
  181.         MyCaos.a6               =(ULONG) PPTBase;       
  182.         ( VOID)PPCCallOS(&MyCaos);
  183. }
  184.  
  185. #define GetBackgroundColor(frame, pixel)        _GetBackgroundColor(PPTSUPP_BASE_NAME, frame, pixel)
  186.  
  187. static __inline  PERROR
  188. _GetBackgroundColor(void *PPTBase, FRAME *frame, ROWPTR pixel)
  189. {
  190. struct Caos     MyCaos;
  191.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  192. //      MyCaos.M68kStart        =       NULL;
  193. //      MyCaos.M68kSize         =       0;
  194.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  195. //      MyCaos.PPCStart         =       NULL;
  196. //      MyCaos.PPCSize          =       0;
  197.         MyCaos.a0               =(ULONG) frame;
  198.         MyCaos.a1               =(ULONG) pixel;
  199.         MyCaos.caos_Un.Offset   =       (-192);
  200.         MyCaos.a6               =(ULONG) PPTBase;       
  201.         return(( PERROR)PPCCallOS(&MyCaos));
  202. }
  203.  
  204. #define GetBitMapRow(frame, row)        _GetBitMapRow(PPTSUPP_BASE_NAME, frame, row)
  205.  
  206. static __inline  UBYTE *
  207. _GetBitMapRow(void *PPTBase, FRAME *frame, WORD row)
  208. {
  209. struct Caos     MyCaos;
  210.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  211. //      MyCaos.M68kStart        =       NULL;
  212. //      MyCaos.M68kSize         =       0;
  213.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  214. //      MyCaos.PPCStart         =       NULL;
  215. //      MyCaos.PPCSize          =       0;
  216.         MyCaos.a0               =(ULONG) frame;
  217.         MyCaos.d0               =(ULONG) row;
  218.         MyCaos.caos_Un.Offset   =       (-102);
  219.         MyCaos.a6               =(ULONG) PPTBase;       
  220.         return(( UBYTE *)PPCCallOS(&MyCaos));
  221. }
  222.  
  223. #define GetNPixelRows(frame, buf, row, nRows)   _GetNPixelRows(PPTSUPP_BASE_NAME, frame, buf, row, nRows)
  224.  
  225. static __inline  UWORD
  226. _GetNPixelRows(void *PPTBase, FRAME *frame, ROWPTR *buf, WORD row, UWORD nRows)
  227. {
  228. struct Caos     MyCaos;
  229.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  230. //      MyCaos.M68kStart        =       NULL;
  231. //      MyCaos.M68kSize         =       0;
  232.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  233. //      MyCaos.PPCStart         =       NULL;
  234. //      MyCaos.PPCSize          =       0;
  235.         MyCaos.a0               =(ULONG) frame;
  236.         MyCaos.a1               =(ULONG) buf;
  237.         MyCaos.d0               =(ULONG) row;
  238.         MyCaos.d1               =(ULONG) nRows;
  239.         MyCaos.caos_Un.Offset   =       (-90);
  240.         MyCaos.a6               =(ULONG) PPTBase;       
  241.         return(( UWORD)PPCCallOS(&MyCaos));
  242. }
  243.  
  244. #define GetOptions(name)        _GetOptions(PPTSUPP_BASE_NAME, name)
  245.  
  246. static __inline  APTR
  247. _GetOptions(void *PPTBase, STRPTR name)
  248. {
  249. struct Caos     MyCaos;
  250.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  251. //      MyCaos.M68kStart        =       NULL;
  252. //      MyCaos.M68kSize         =       0;
  253.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  254. //      MyCaos.PPCStart         =       NULL;
  255. //      MyCaos.PPCSize          =       0;
  256.         MyCaos.a0               =(ULONG) name;
  257.         MyCaos.caos_Un.Offset   =       (-198);
  258.         MyCaos.a6               =(ULONG) PPTBase;       
  259.         return(( APTR)PPCCallOS(&MyCaos));
  260. }
  261.  
  262. #define GetPixel(frame, row, col)       _GetPixel(PPTSUPP_BASE_NAME, frame, row, col)
  263.  
  264. static __inline  APTR
  265. _GetPixel(void *PPTBase, FRAME *frame, WORD row, WORD col)
  266. {
  267. struct Caos     MyCaos;
  268.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  269. //      MyCaos.M68kStart        =       NULL;
  270. //      MyCaos.M68kSize         =       0;
  271.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  272. //      MyCaos.PPCStart         =       NULL;
  273. //      MyCaos.PPCSize          =       0;
  274.         MyCaos.a0               =(ULONG) frame;
  275.         MyCaos.d0               =(ULONG) row;
  276.         MyCaos.d1               =(ULONG) col;
  277.         MyCaos.caos_Un.Offset   =       (-66);
  278.         MyCaos.a6               =(ULONG) PPTBase;       
  279.         return(( APTR)PPCCallOS(&MyCaos));
  280. }
  281.  
  282. #define GetPixelRow(frame, row) _GetPixelRow(PPTSUPP_BASE_NAME, frame, row)
  283.  
  284. static __inline  ROWPTR
  285. _GetPixelRow(void *PPTBase, FRAME *frame, WORD row)
  286. {
  287. struct Caos     MyCaos;
  288.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  289. //      MyCaos.M68kStart        =       NULL;
  290. //      MyCaos.M68kSize         =       0;
  291.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  292. //      MyCaos.PPCStart         =       NULL;
  293. //      MyCaos.PPCSize          =       0;
  294.         MyCaos.a0               =(ULONG) frame;
  295.         MyCaos.d0               =(ULONG) row;
  296.         MyCaos.caos_Un.Offset   =       (-78);
  297.         MyCaos.a6               =(ULONG) PPTBase;       
  298.         return(( ROWPTR)PPCCallOS(&MyCaos));
  299. }
  300.  
  301. #define GetStr(string)  _GetStr(PPTSUPP_BASE_NAME, string)
  302.  
  303. static __inline  STRPTR
  304. _GetStr(void *PPTBase, struct LocaleString *string)
  305. {
  306. struct Caos     MyCaos;
  307.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  308. //      MyCaos.M68kStart        =       NULL;
  309. //      MyCaos.M68kSize         =       0;
  310.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  311. //      MyCaos.PPCStart         =       NULL;
  312. //      MyCaos.PPCSize          =       0;
  313.         MyCaos.a0               =(ULONG) string;
  314.         MyCaos.caos_Un.Offset   =       (-168);
  315.         MyCaos.a6               =(ULONG) PPTBase;       
  316.         return(( STRPTR)PPCCallOS(&MyCaos));
  317. }
  318.  
  319. #define InitFrame(frame)        _InitFrame(PPTSUPP_BASE_NAME, frame)
  320.  
  321. static __inline  PERROR
  322. _InitFrame(void *PPTBase, FRAME *frame)
  323. {
  324. struct Caos     MyCaos;
  325.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  326. //      MyCaos.M68kStart        =       NULL;
  327. //      MyCaos.M68kSize         =       0;
  328.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  329. //      MyCaos.PPCStart         =       NULL;
  330. //      MyCaos.PPCSize          =       0;
  331.         MyCaos.a0               =(ULONG) frame;
  332.         MyCaos.caos_Un.Offset   =       (-42);
  333.         MyCaos.a6               =(ULONG) PPTBase;       
  334.         return(( PERROR)PPCCallOS(&MyCaos));
  335. }
  336.  
  337. #define InitProgress(frame, txt, min, max)      _InitProgress(PPTSUPP_BASE_NAME, frame, txt, min, max)
  338.  
  339. static __inline  VOID
  340. _InitProgress(void *PPTBase, FRAME *frame, char *txt, ULONG min, ULONG max)
  341. {
  342. struct Caos     MyCaos;
  343.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  344. //      MyCaos.M68kStart        =       NULL;
  345. //      MyCaos.M68kSize         =       0;
  346.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  347. //      MyCaos.PPCStart         =       NULL;
  348. //      MyCaos.PPCSize          =       0;
  349.         MyCaos.a0               =(ULONG) frame;
  350.         MyCaos.a1               =(ULONG) txt;
  351.         MyCaos.d0               =(ULONG) min;
  352.         MyCaos.d1               =(ULONG) max;
  353.         MyCaos.caos_Un.Offset   =       (-114);
  354.         MyCaos.a6               =(ULONG) PPTBase;       
  355.         ( VOID)PPCCallOS(&MyCaos);
  356. }
  357.  
  358. #define MakeFrame(frame)        _MakeFrame(PPTSUPP_BASE_NAME, frame)
  359.  
  360. static __inline  FRAME *
  361. _MakeFrame(void *PPTBase, FRAME *frame)
  362. {
  363. struct Caos     MyCaos;
  364.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  365. //      MyCaos.M68kStart        =       NULL;
  366. //      MyCaos.M68kSize         =       0;
  367.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  368. //      MyCaos.PPCStart         =       NULL;
  369. //      MyCaos.PPCSize          =       0;
  370.         MyCaos.a0               =(ULONG) frame;
  371.         MyCaos.caos_Un.Offset   =       (-36);
  372.         MyCaos.a6               =(ULONG) PPTBase;       
  373.         return(( FRAME *)PPCCallOS(&MyCaos));
  374. }
  375.  
  376. #define NewFrame(height, width, components)     _NewFrame(PPTSUPP_BASE_NAME, height, width, components)
  377.  
  378. static __inline  FRAME *
  379. _NewFrame(void *PPTBase, ULONG height, ULONG width, UBYTE components)
  380. {
  381. struct Caos     MyCaos;
  382.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  383. //      MyCaos.M68kStart        =       NULL;
  384. //      MyCaos.M68kSize         =       0;
  385.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  386. //      MyCaos.PPCStart         =       NULL;
  387. //      MyCaos.PPCSize          =       0;
  388.         MyCaos.d0               =(ULONG) height;
  389.         MyCaos.d1               =(ULONG) width;
  390.         MyCaos.d2               =(ULONG) components;
  391.         MyCaos.caos_Un.Offset   =       (-30);
  392.         MyCaos.a6               =(ULONG) PPTBase;       
  393.         return(( FRAME *)PPCCallOS(&MyCaos));
  394. }
  395.  
  396. #define ObtainPreviewFrameA(frame, tags)        _ObtainPreviewFrameA(PPTSUPP_BASE_NAME, frame, tags)
  397.  
  398. static __inline  FRAME *
  399. _ObtainPreviewFrameA(void *PPTBase, FRAME *frame, struct TagItem *tags)
  400. {
  401. struct Caos     MyCaos;
  402.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  403. //      MyCaos.M68kStart        =       NULL;
  404. //      MyCaos.M68kSize         =       0;
  405.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  406. //      MyCaos.PPCStart         =       NULL;
  407. //      MyCaos.PPCSize          =       0;
  408.         MyCaos.a0               =(ULONG) frame;
  409.         MyCaos.a1               =(ULONG) tags;
  410.         MyCaos.caos_Un.Offset   =       (-228);
  411.         MyCaos.a6               =(ULONG) PPTBase;       
  412.         return(( FRAME *)PPCCallOS(&MyCaos));
  413. }
  414.  
  415. #ifndef NO_PPCINLINE_STDARG
  416. #define ObtainPreviewFrame(a0, tags...) \
  417.         ({ULONG _tags[] = { tags }; ObtainPreviewFrameA((a0), (struct TagItem *)_tags);})
  418. #endif /* !NO_PPCINLINE_STDARG */
  419.  
  420. #define PlanarToChunky(source, dest, width, depth)      _PlanarToChunky(PPTSUPP_BASE_NAME, source, dest, width, depth)
  421.  
  422. static __inline  VOID
  423. _PlanarToChunky(void *PPTBase, UBYTE **source, ROWPTR dest, ULONG width, UWORD depth)
  424. {
  425. struct Caos     MyCaos;
  426.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  427. //      MyCaos.M68kStart        =       NULL;
  428. //      MyCaos.M68kSize         =       0;
  429.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  430. //      MyCaos.PPCStart         =       NULL;
  431. //      MyCaos.PPCSize          =       0;
  432.         MyCaos.a0               =(ULONG) source;
  433.         MyCaos.a1               =(ULONG) dest;
  434.         MyCaos.d0               =(ULONG) width;
  435.         MyCaos.d1               =(ULONG) depth;
  436.         MyCaos.caos_Un.Offset   =       (-156);
  437.         MyCaos.a6               =(ULONG) PPTBase;       
  438.         ( VOID)PPCCallOS(&MyCaos);
  439. }
  440.  
  441. #define Progress(frame, done)   _Progress(PPTSUPP_BASE_NAME, frame, done)
  442.  
  443. static __inline  BOOL
  444. _Progress(void *PPTBase, FRAME *frame, ULONG done)
  445. {
  446. struct Caos     MyCaos;
  447.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  448. //      MyCaos.M68kStart        =       NULL;
  449. //      MyCaos.M68kSize         =       0;
  450.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  451. //      MyCaos.PPCStart         =       NULL;
  452. //      MyCaos.PPCSize          =       0;
  453.         MyCaos.a0               =(ULONG) frame;
  454.         MyCaos.d0               =(ULONG) done;
  455.         MyCaos.caos_Un.Offset   =       (-120);
  456.         MyCaos.a6               =(ULONG) PPTBase;       
  457.         return(( BOOL)PPCCallOS(&MyCaos));
  458. }
  459.  
  460. #define PutNPixelRows(frame, buf, row, nRows)   _PutNPixelRows(PPTSUPP_BASE_NAME, frame, buf, row, nRows)
  461.  
  462. static __inline  VOID
  463. _PutNPixelRows(void *PPTBase, FRAME *frame, ROWPTR *buf, WORD row, UWORD nRows)
  464. {
  465. struct Caos     MyCaos;
  466.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  467. //      MyCaos.M68kStart        =       NULL;
  468. //      MyCaos.M68kSize         =       0;
  469.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  470. //      MyCaos.PPCStart         =       NULL;
  471. //      MyCaos.PPCSize          =       0;
  472.         MyCaos.a0               =(ULONG) frame;
  473.         MyCaos.a1               =(ULONG) buf;
  474.         MyCaos.d0               =(ULONG) row;
  475.         MyCaos.d1               =(ULONG) nRows;
  476.         MyCaos.caos_Un.Offset   =       (-96);
  477.         MyCaos.a6               =(ULONG) PPTBase;       
  478.         ( VOID)PPCCallOS(&MyCaos);
  479. }
  480.  
  481. #define PutOptions(name, data, len)     _PutOptions(PPTSUPP_BASE_NAME, name, data, len)
  482.  
  483. static __inline  PERROR
  484. _PutOptions(void *PPTBase, STRPTR name, APTR data, ULONG len)
  485. {
  486. struct Caos     MyCaos;
  487.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  488. //      MyCaos.M68kStart        =       NULL;
  489. //      MyCaos.M68kSize         =       0;
  490.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  491. //      MyCaos.PPCStart         =       NULL;
  492. //      MyCaos.PPCSize          =       0;
  493.         MyCaos.a0               =(ULONG) name;
  494.         MyCaos.a1               =(ULONG) data;
  495.         MyCaos.d0               =(ULONG) len;
  496.         MyCaos.caos_Un.Offset   =       (-204);
  497.         MyCaos.a6               =(ULONG) PPTBase;       
  498.         return(( PERROR)PPCCallOS(&MyCaos));
  499. }
  500.  
  501. #define PutPixel(frame, row, col, data) _PutPixel(PPTSUPP_BASE_NAME, frame, row, col, data)
  502.  
  503. static __inline  VOID
  504. _PutPixel(void *PPTBase, FRAME *frame, WORD row, WORD col, APTR data)
  505. {
  506. struct Caos     MyCaos;
  507.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  508. //      MyCaos.M68kStart        =       NULL;
  509. //      MyCaos.M68kSize         =       0;
  510.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  511. //      MyCaos.PPCStart         =       NULL;
  512. //      MyCaos.PPCSize          =       0;
  513.         MyCaos.a0               =(ULONG) frame;
  514.         MyCaos.d0               =(ULONG) row;
  515.         MyCaos.d1               =(ULONG) col;
  516.         MyCaos.a1               =(ULONG) data;
  517.         MyCaos.caos_Un.Offset   =       (-72);
  518.         MyCaos.a6               =(ULONG) PPTBase;       
  519.         ( VOID)PPCCallOS(&MyCaos);
  520. }
  521.  
  522. #define PutPixelRow(frame, row, data)   _PutPixelRow(PPTSUPP_BASE_NAME, frame, row, data)
  523.  
  524. static __inline  VOID
  525. _PutPixelRow(void *PPTBase, FRAME *frame, WORD row, APTR data)
  526. {
  527. struct Caos     MyCaos;
  528.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  529. //      MyCaos.M68kStart        =       NULL;
  530. //      MyCaos.M68kSize         =       0;
  531.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  532. //      MyCaos.PPCStart         =       NULL;
  533. //      MyCaos.PPCSize          =       0;
  534.         MyCaos.a0               =(ULONG) frame;
  535.         MyCaos.d0               =(ULONG) row;
  536.         MyCaos.a1               =(ULONG) data;
  537.         MyCaos.caos_Un.Offset   =       (-84);
  538.         MyCaos.a6               =(ULONG) PPTBase;       
  539.         ( VOID)PPCCallOS(&MyCaos);
  540. }
  541.  
  542. #define ReleasePreviewFrame(frame)      _ReleasePreviewFrame(PPTSUPP_BASE_NAME, frame)
  543.  
  544. static __inline  VOID
  545. _ReleasePreviewFrame(void *PPTBase, FRAME *frame)
  546. {
  547. struct Caos     MyCaos;
  548.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  549. //      MyCaos.M68kStart        =       NULL;
  550. //      MyCaos.M68kSize         =       0;
  551.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  552. //      MyCaos.PPCStart         =       NULL;
  553. //      MyCaos.PPCSize          =       0;
  554.         MyCaos.a0               =(ULONG) frame;
  555.         MyCaos.caos_Un.Offset   =       (-234);
  556.         MyCaos.a6               =(ULONG) PPTBase;       
  557.         ( VOID)PPCCallOS(&MyCaos);
  558. }
  559.  
  560. #define RemFrame(frame) _RemFrame(PPTSUPP_BASE_NAME, frame)
  561.  
  562. static __inline  VOID
  563. _RemFrame(void *PPTBase, FRAME *frame)
  564. {
  565. struct Caos     MyCaos;
  566.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  567. //      MyCaos.M68kStart        =       NULL;
  568. //      MyCaos.M68kSize         =       0;
  569.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  570. //      MyCaos.PPCStart         =       NULL;
  571. //      MyCaos.PPCSize          =       0;
  572.         MyCaos.a0               =(ULONG) frame;
  573.         MyCaos.caos_Un.Offset   =       (-48);
  574.         MyCaos.a6               =(ULONG) PPTBase;       
  575.         ( VOID)PPCCallOS(&MyCaos);
  576. }
  577.  
  578. #define RemoveExtension(frame, name)    _RemoveExtension(PPTSUPP_BASE_NAME, frame, name)
  579.  
  580. static __inline  PERROR
  581. _RemoveExtension(void *PPTBase, FRAME *frame, STRPTR name)
  582. {
  583. struct Caos     MyCaos;
  584.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  585. //      MyCaos.M68kStart        =       NULL;
  586. //      MyCaos.M68kSize         =       0;
  587.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  588. //      MyCaos.PPCStart         =       NULL;
  589. //      MyCaos.PPCSize          =       0;
  590.         MyCaos.a0               =(ULONG) frame;
  591.         MyCaos.a1               =(ULONG) name;
  592.         MyCaos.caos_Un.Offset   =       (-222);
  593.         MyCaos.a6               =(ULONG) PPTBase;       
  594.         return(( PERROR)PPCCallOS(&MyCaos));
  595. }
  596.  
  597. #define RenderFrame(frame, rastport, location, flags)   _RenderFrame(PPTSUPP_BASE_NAME, frame, rastport, location, flags)
  598.  
  599. static __inline  PERROR
  600. _RenderFrame(void *PPTBase, FRAME *frame, struct RastPort *rastport, struct IBox *location, ULONG flags)
  601. {
  602. struct Caos     MyCaos;
  603.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  604. //      MyCaos.M68kStart        =       NULL;
  605. //      MyCaos.M68kSize         =       0;
  606.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  607. //      MyCaos.PPCStart         =       NULL;
  608. //      MyCaos.PPCSize          =       0;
  609.         MyCaos.a0               =(ULONG) frame;
  610.         MyCaos.a1               =(ULONG) rastport;
  611.         MyCaos.a2               =(ULONG) location;
  612.         MyCaos.d0               =(ULONG) flags;
  613.         MyCaos.caos_Un.Offset   =       (-240);
  614.         MyCaos.a6               =(ULONG) PPTBase;       
  615.         return(( PERROR)PPCCallOS(&MyCaos));
  616. }
  617.  
  618. #define SetErrorCode(frame, error)      _SetErrorCode(PPTSUPP_BASE_NAME, frame, error)
  619.  
  620. static __inline  VOID
  621. _SetErrorCode(void *PPTBase, FRAME *frame, PERROR error)
  622. {
  623. struct Caos     MyCaos;
  624.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  625. //      MyCaos.M68kStart        =       NULL;
  626. //      MyCaos.M68kSize         =       0;
  627.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  628. //      MyCaos.PPCStart         =       NULL;
  629. //      MyCaos.PPCSize          =       0;
  630.         MyCaos.a0               =(ULONG) frame;
  631.         MyCaos.d0               =(ULONG) error;
  632.         MyCaos.caos_Un.Offset   =       (-138);
  633.         MyCaos.a6               =(ULONG) PPTBase;       
  634.         ( VOID)PPCCallOS(&MyCaos);
  635. }
  636.  
  637. #define SetErrorMsg(frame, errorstring) _SetErrorMsg(PPTSUPP_BASE_NAME, frame, errorstring)
  638.  
  639. static __inline  VOID
  640. _SetErrorMsg(void *PPTBase, FRAME *frame, UBYTE *errorstring)
  641. {
  642. struct Caos     MyCaos;
  643.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  644. //      MyCaos.M68kStart        =       NULL;
  645. //      MyCaos.M68kSize         =       0;
  646.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  647. //      MyCaos.PPCStart         =       NULL;
  648. //      MyCaos.PPCSize          =       0;
  649.         MyCaos.a0               =(ULONG) frame;
  650.         MyCaos.a1               =(ULONG) errorstring;
  651.         MyCaos.caos_Un.Offset   =       (-144);
  652.         MyCaos.a6               =(ULONG) PPTBase;       
  653.         ( VOID)PPCCallOS(&MyCaos);
  654. }
  655.  
  656. #define StartInput(frame, mid, area)    _StartInput(PPTSUPP_BASE_NAME, frame, mid, area)
  657.  
  658. static __inline  BOOL
  659. _StartInput(void *PPTBase, FRAME *frame, ULONG mid, struct PPTMessage *area)
  660. {
  661. struct Caos     MyCaos;
  662.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  663. //      MyCaos.M68kStart        =       NULL;
  664. //      MyCaos.M68kSize         =       0;
  665.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  666. //      MyCaos.PPCStart         =       NULL;
  667. //      MyCaos.PPCSize          =       0;
  668.         MyCaos.a0               =(ULONG) frame;
  669.         MyCaos.d0               =(ULONG) mid;
  670.         MyCaos.a1               =(ULONG) area;
  671.         MyCaos.caos_Un.Offset   =       (-180);
  672.         MyCaos.a6               =(ULONG) PPTBase;       
  673.         return(( BOOL)PPCCallOS(&MyCaos));
  674. }
  675.  
  676. #define StopInput(frame)        _StopInput(PPTSUPP_BASE_NAME, frame)
  677.  
  678. static __inline  VOID
  679. _StopInput(void *PPTBase, FRAME *frame)
  680. {
  681. struct Caos     MyCaos;
  682.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  683. //      MyCaos.M68kStart        =       NULL;
  684. //      MyCaos.M68kSize         =       0;
  685.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  686. //      MyCaos.PPCStart         =       NULL;
  687. //      MyCaos.PPCSize          =       0;
  688.         MyCaos.a0               =(ULONG) frame;
  689.         MyCaos.caos_Un.Offset   =       (-186);
  690.         MyCaos.a6               =(ULONG) PPTBase;       
  691.         ( VOID)PPCCallOS(&MyCaos);
  692. }
  693.  
  694. #define TagData(tagvalue, list) _TagData(PPTSUPP_BASE_NAME, tagvalue, list)
  695.  
  696. static __inline  ULONG
  697. _TagData(void *PPTBase, Tag tagvalue, const struct TagItem *list)
  698. {
  699. struct Caos     MyCaos;
  700.         MyCaos.M68kCacheMode    =       IF_CACHEFLUSHALL;
  701. //      MyCaos.M68kStart        =       NULL;
  702. //      MyCaos.M68kSize         =       0;
  703.         MyCaos.PPCCacheMode     =       IF_CACHEFLUSHALL;
  704. //      MyCaos.PPCStart         =       NULL;
  705. //      MyCaos.PPCSize          =       0;
  706.         MyCaos.d0               =(ULONG) tagvalue;
  707.         MyCaos.a0               =(ULONG) list;
  708.         MyCaos.caos_Un.Offset   =       (-174);
  709.         MyCaos.a6               =(ULONG) PPTBase;       
  710.         return(( ULONG)PPCCallOS(&MyCaos));
  711. }
  712.  
  713. #endif /* SASC Pragmas */
  714. #endif /* !_PPCPRAGMA_PPTSUPP_H */
  715.