/packages/amunits/src/otherlibs/guigfx.pas

https://github.com/slibre/freepascal · Pascal · 787 lines · 620 code · 80 blank · 87 comment · 6 complexity · af7c0d4912577079ab61958cc09cd453 MD5 · raw file 

    

  1. {
    2. 

  2.   This file is part of the Free Pascal run time library.
    3. 

  3. 

  4.   A file in Amiga system run time library.
    5. 

  5.   Copyright (c) 2003 by Nils Sjöholm.
    6. 

  6.   member of the Amiga RTL development team.
    7. 

  7. 

  8.   This is a unit for guigfx.library
    9. 

  9. 

  10.   See the file COPYING.FPC, included in this distribution,
    11. 

  11.   for details about the copyright.
    12. 

  12. 

  13.   This program is distributed in the hope that it will be useful,
    14. 

  14.   but WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    16. 

  16. 

  17. **********************************************************************}
    18. 

  18. {
    19. 

  19.   History:
    20. 

  20. 

  21.   First version of this unit.
    22. 

  22.   15 Jan 2003.
    23. 

  23. 

  24.   Changed cardinal > longword.
    25. 

  25.   Changed startcode for unit.
    26. 

  26.   12 Feb 2003.
    27. 

  27. 

  28.   nils.sjoholm@mailbox.swipnet.se Nils Sjoholm
    29. 

  29. }
    30. 

  30. 

  31. {$mode objfpc}
    32. 

  32. {$I useamigasmartlink.inc}
    33. 

  33. {$ifdef use_amiga_smartlink}
    34. 

  34.    {$smartlink on}
    35. 

  35. {$endif use_amiga_smartlink}
    36. 

  36. 

  37. UNIT GUIGFX;
    38. 

  38. 

  39. INTERFACE
    40. 

  40. USES Exec,utility,graphics;
    41. 

  41. 

  42. VAR GuiGFXBase : pLibrary;
    43. 

  43. 

  44. const
    45. 

  45.     GUIGFXNAME : PChar = 'guigfx.library';
    46. 

  46. 

  47. 

  48.   {
    49. 

  49.         $VER: guigfx.h 17.2 (9.2.2000)
    50. 

  50. 

  51.         guigfx.library definitions
    52. 

  52. 

  53.         © 1997-2000 TEK neoscientists
    54. 

  54.    }
    55. 

  55. 

  56.   {
    57. 

  57.         Tags
    58. 

  58.     }
    59. 

  59. 

  60.   const
    61. 

  61.      GGFX_Dummy = 4567 + TAG_USER;
    62. 

  62.   { strictly private  }
    63. 

  63.      GGFX_Owner = GGFX_Dummy + 0;
    64. 

  64.      GGFX_HSType = GGFX_Dummy + 1;
    65. 

  65.      GGFX_DitherMode = GGFX_Dummy + 2;
    66. 

  66.      GGFX_DitherAmount = GGFX_Dummy + 3;
    67. 

  67.      GGFX_AutoDither = GGFX_Dummy + 4;
    68. 

  68.      GGFX_DitherThreshold = GGFX_Dummy + 5;
    69. 

  69.      GGFX_AspectX = GGFX_Dummy + 6;
    70. 

  70.      GGFX_AspectY = GGFX_Dummy + 7;
    71. 

  71.      GGFX_PixelFormat = GGFX_Dummy + 8;
    72. 

  72.      GGFX_Palette = GGFX_Dummy + 9;
    73. 

  73.      GGFX_PaletteFormat = GGFX_Dummy + 10;
    74. 

  74.      GGFX_NumColors = GGFX_Dummy + 11;
    75. 

  75.      GGFX_Precision = GGFX_Dummy + 12;
    76. 

  76.      GGFX_Weight = GGFX_Dummy + 13;
    77. 

  77.      GGFX_Ratio = GGFX_Dummy + 14;
    78. 

  78.      GGFX_SourceWidth = GGFX_Dummy + 15;
    79. 

  79.      GGFX_SourceHeight = GGFX_Dummy + 16;
    80. 

  80.      GGFX_SourceX = GGFX_Dummy + 17;
    81. 

  81.      GGFX_SourceY = GGFX_Dummy + 18;
    82. 

  82.      GGFX_DestWidth = GGFX_Dummy + 19;
    83. 

  83.      GGFX_DestHeight = GGFX_Dummy + 20;
    84. 

  84.      GGFX_DestX = GGFX_Dummy + 21;
    85. 

  85.      GGFX_DestY = GGFX_Dummy + 22;
    86. 

  86.      GGFX_CallBackHook = GGFX_Dummy + 23;
    87. 

  87.      GGFX_ErrorCode = GGFX_Dummy + 24;
    88. 

  88.      GGFX_MaxAllocPens = GGFX_Dummy + 25;
    89. 

  89.      GGFX_BufferSize = GGFX_Dummy + 26;
    90. 

  90.      GGFX_AlphaPresent = GGFX_Dummy + 27;
    91. 

  91.      GGFX_Independent = GGFX_Dummy + 28;
    92. 

  92.      GGFX_ModeID = GGFX_Dummy + 29;
    93. 

  93.      GGFX_PenTable = GGFX_Dummy + 30;
    94. 

  94.   { obsolete  }
    95. 

  95.      GGFX_License = GGFX_Dummy + 31;
    96. 

  96.      GGFX_BGColor = GGFX_Dummy + 32;
    97. 

  97.      GGFX_UseMask = GGFX_Dummy + 33;
    98. 

  98.      GGFX_RastLock = GGFX_Dummy + 34;
    99. 

  99.      GGFX_FormatName = GGFX_Dummy + 35;
    100. 

  100.   {
    101. 

  101.         Picture Attributes
    102. 

  102.     }
    103. 

  103.      PICATTR_Dummy = 123 + TAG_USER;
    104. 

  104.      PICATTR_Width = PICATTR_Dummy + 0;
    105. 

  105.      PICATTR_Height = PICATTR_Dummy + 1;
    106. 

  106.      PICATTR_RawData = PICATTR_Dummy + 2;
    107. 

  107.      PICATTR_PixelFormat = PICATTR_Dummy + 3;
    108. 

  108.      PICATTR_AspectX = PICATTR_Dummy + 4;
    109. 

  109.      PICATTR_AspectY = PICATTR_Dummy + 5;
    110. 

  110.      PICATTR_AlphaPresent = PICATTR_Dummy + 6;
    111. 

  111.   {
    112. 

  112.         Picture Methods
    113. 

  113.     }
    114. 

  114.      PICMTHD_CROP = 1;
    115. 

  115.      PICMTHD_RENDER = 2;
    116. 

  116.      PICMTHD_SCALE = 3;
    117. 

  117.      PICMTHD_MIX = 4;
    118. 

  118.      PICMTHD_SETALPHA = 5;
    119. 

  119.      PICMTHD_MIXALPHA = 6;
    120. 

  120.      PICMTHD_MAPDRAWHANDLE = 7;
    121. 

  121.      PICMTHD_CREATEALPHAMASK = 8;
    122. 

  122.      PICMTHD_TINT = 9;
    123. 

  123.      PICMTHD_TEXTURE = 10;
    124. 

  124.      PICMTHD_SET = 11;
    125. 

  125.      PICMTHD_TINTALPHA = 12;
    126. 

  126.      PICMTHD_INSERT = 13;
    127. 

  127.      PICMTHD_FLIPX = 14;
    128. 

  128.      PICMTHD_FLIPY = 15;
    129. 

  129.      PICMTHD_CHECKAUTODITHER = 16;
    130. 

  130.      PICMTHD_NEGATIVE = 17;
    131. 

  131.      PICMTHD_AUTOCROP = 18;
    132. 

  132.      PICMTHD_CONVOLVE = 19;
    133. 

  133.   {
    134. 

  134.         hook message types
    135. 

  135.     }
    136. 

  136.      GGFX_MSGTYPE_LINEDRAWN = 1;
    137. 

  137.   {
    138. 

  138.         picture locking
    139. 

  139.     }
    140. 

  140.      LOCKMODE_DRAWHANDLE = 1;
    141. 

  141.      LOCKMODE_FORCE = 1 shl 8;
    142. 

  142.      LOCKMODE_MASK = $ff;
    143. 

  143. 

  144.   {
    145. 

  145.         bitmap attributes
    146. 

  146.         (strictly internal)
    147. 

  147.     }
    148. 

  148. 

  149.   const
    150. 

  150.      BMAPATTR_Width = 0 + TAG_USER;
    151. 

  151.      BMAPATTR_Height = 1 + TAG_USER;
    152. 

  152.      BMAPATTR_Depth = 2 + TAG_USER;
    153. 

  153.      BMAPATTR_CyberGFX = 3 + TAG_USER;
    154. 

  154.      BMAPATTR_BitMapFormat = 4 + TAG_USER;
    155. 

  155.      BMAPATTR_PixelFormat = 5 + TAG_USER;
    156. 

  156.      BMAPATTR_Flags = 6 + TAG_USER;
    157. 

  157. 

  158. 

  159. FUNCTION AddPaletteA(psm : POINTER; palette : POINTER; tags : pTagItem) : POINTER;
    160. 

  160. FUNCTION AddPictureA(psm : POINTER; pic : POINTER; tags : pTagItem) : POINTER;
    161. 

  161. FUNCTION AddPixelArrayA(psm : POINTER; _array : POINTER; width : WORD; height : WORD; tags : pTagItem) : POINTER;
    162. 

  162. FUNCTION ClonePictureA(pic : POINTER; tags : pTagItem) : POINTER;
    163. 

  163. FUNCTION CreateDirectDrawHandleA(drawhandle : POINTER; sw : WORD; sh : WORD; dw : WORD; dh : WORD; tags : pTagItem) : POINTER;
    164. 

  164. FUNCTION CreatePenShareMapA(tags : pTagItem) : POINTER;
    165. 

  165. FUNCTION CreatePictureBitMapA(drawhandle : POINTER; pic : POINTER; tags : pTagItem) : pBitMap;
    166. 

  166. FUNCTION CreatePictureMaskA(pic : POINTER; mask : pCHAR; maskwidth : WORD; tags : pTagItem) : BOOLEAN;
    167. 

  167. PROCEDURE DeleteDirectDrawHandle(ddh : POINTER);
    168. 

  168. PROCEDURE DeletePenShareMap(psm : POINTER);
    169. 

  169. PROCEDURE DeletePicture(pic : POINTER);
    170. 

  170. FUNCTION DirectDrawTrueColorA(ddh : POINTER; _array : pULONG; x : WORD; y : WORD; tags : pTagItem) : BOOLEAN;
    171. 

  171. FUNCTION DoPictureMethodA(pic : POINTER; method : longword; arguments : pULONG) : longword;
    172. 

  172. FUNCTION DrawPictureA(drawhandle : POINTER; pic : POINTER; x : WORD; y : WORD; tags : pTagItem) : BOOLEAN;
    173. 

  173. FUNCTION GetPictureAttrsA(pic : POINTER; tags : pTagItem) : longword;
    174. 

  174. FUNCTION IsPictureA(filename : pCHAR; tags : pTagItem) : BOOLEAN;
    175. 

  175. FUNCTION LoadPictureA(filename : pCHAR; tags : pTagItem) : POINTER;
    176. 

  176. FUNCTION LockPictureA(pic : POINTER; mode : longword; args : pULONG) : longword;
    177. 

  177. FUNCTION MakePictureA(_array : POINTER; width : WORD; height : WORD; tags : pTagItem) : POINTER;
    178. 

  178. FUNCTION MapPaletteA(drawhandle : POINTER; palette : POINTER; pentab : pCHAR; tags : pTagItem) : BOOLEAN;
    179. 

  179. FUNCTION MapPenA(drawhandle : POINTER; rgb : longword; tags : pTagItem) : LONGINT;
    180. 

  180. FUNCTION ObtainDrawHandleA(psm : POINTER; a1arg : pRastPort; cm : pColorMap; tags : pTagItem) : POINTER;
    181. 

  181. FUNCTION ReadPictureA(a0arg : pRastPort; colormap : pColorMap; x : WORD; y : WORD; width : WORD; height : WORD; tags : pTagItem) : POINTER;
    182. 

  182. PROCEDURE ReleaseDrawHandle(drawhandle : POINTER);
    183. 

  183. PROCEDURE RemColorHandle(colorhandle : POINTER);
    184. 

  184. PROCEDURE UnLockPicture(pic : POINTER; mode : longword);
    185. 

  185. {
    186. 

  186.  Functions and procedures with array of const go here
    187. 

  187. }
    188. 

  188. FUNCTION AddPalette(psm : POINTER; palette : POINTER; const tags : Array Of Const) : POINTER;
    189. 

  189. FUNCTION AddPicture(psm : POINTER; pic : POINTER; const tags : Array Of Const) : POINTER;
    190. 

  190. FUNCTION AddPixelArray(psm : POINTER; _array : POINTER; width : WORD; height : WORD; const tags : Array Of Const) : POINTER;
    191. 

  191. FUNCTION ClonePicture(pic : POINTER; const tags : Array Of Const) : POINTER;
    192. 

  192. FUNCTION CreateDirectDrawHandle(drawhandle : POINTER; sw : WORD; sh : WORD; dw : WORD; dh : WORD; const tags : Array Of Const) : POINTER;
    193. 

  193. FUNCTION CreatePenShareMap(const tags : Array Of Const) : POINTER;
    194. 

  194. FUNCTION CreatePictureBitMap(drawhandle : POINTER; pic : POINTER; const tags : Array Of Const) : pBitMap;
    195. 

  195. FUNCTION CreatePictureMask(pic : POINTER; mask : pCHAR; maskwidth : WORD; const tags : Array Of Const) : BOOLEAN;
    196. 

  196. FUNCTION DirectDrawTrueColor(ddh : POINTER; _array : pULONG; x : WORD; y : WORD; const tags : Array Of Const) : BOOLEAN;
    197. 

  197. FUNCTION DoPictureMethod(pic : POINTER; method : longword; const arguments : Array Of Const) : longword;
    198. 

  198. FUNCTION DrawPicture(drawhandle : POINTER; pic : POINTER; x : WORD; y : WORD; const tags : Array Of Const) : BOOLEAN;
    199. 

  199. FUNCTION GetPictureAttrs(pic : POINTER; const tags : Array Of Const) : longword;
    200. 

  200. FUNCTION IsPicture(filename : pCHAR; const tags : Array Of Const) : BOOLEAN;
    201. 

  201. FUNCTION LoadPicture(filename : pCHAR; const tags : Array Of Const) : POINTER;
    202. 

  202. FUNCTION LockPicture(pic : POINTER; mode : longword; const args : Array Of Const) : longword;
    203. 

  203. FUNCTION MakePicture(_array : POINTER; width : WORD; height : WORD; const tags : Array Of Const) : POINTER;
    204. 

  204. FUNCTION MapPalette(drawhandle : POINTER; palette : POINTER; pentab : pCHAR; const tags : Array Of Const) : BOOLEAN;
    205. 

  205. FUNCTION MapPen(drawhandle : POINTER; rgb : longword; const tags : Array Of Const) : LONGINT;
    206. 

  206. FUNCTION ObtainDrawHandle(psm : POINTER; a1arg : pRastPort; cm : pColorMap; const tags : Array Of Const) : POINTER;
    207. 

  207. FUNCTION ReadPicture(a0arg : pRastPort; colormap : pColorMap; x : WORD; y : WORD; width : WORD; height : WORD; const tags : Array Of Const) : POINTER;
    208. 

  208. 

  209. {You can remove this include and use a define instead}
    210. 

  210. {$I useautoopenlib.inc}
    211. 

  211. {$ifdef use_init_openlib}
    212. 

  212. procedure InitGUIGFXLibrary;
    213. 

  213. {$endif use_init_openlib}
    214. 

  214. 

  215. {This is a variable that knows how the unit is compiled}
    216. 

  216. var
    217. 

  217.     GUIGFXIsCompiledHow : longint;
    218. 

  218. 

  219. IMPLEMENTATION
    220. 

  220. 

  221. uses
    222. 

  222. {$ifndef dont_use_openlib}
    223. 

  223. msgbox,
    224. 

  224. {$endif dont_use_openlib}
    225. 

  225. tagsarray,longarray;
    226. 

  226. 

  227. FUNCTION AddPaletteA(psm : POINTER; palette : POINTER; tags : pTagItem) : POINTER;
    228. 

  228. BEGIN
    229. 

  229.   ASM
    230. 

  230.         MOVE.L  A6,-(A7)
    231. 

  231.         MOVEA.L psm,A0
    232. 

  232.         MOVEA.L palette,A1
    233. 

  233.         MOVEA.L tags,A2
    234. 

  234.         MOVEA.L GuiGFXBase,A6
    235. 

  235.         JSR     -072(A6)
    236. 

  236.         MOVEA.L (A7)+,A6
    237. 

  237.         MOVE.L  D0,@RESULT
    238. 

  238.   END;
    239. 

  239. END;
    240. 

  240. 

  241. FUNCTION AddPictureA(psm : POINTER; pic : POINTER; tags : pTagItem) : POINTER;
    242. 

  242. BEGIN
    243. 

  243.   ASM
    244. 

  244.         MOVE.L  A6,-(A7)
    245. 

  245.         MOVEA.L psm,A0
    246. 

  246.         MOVEA.L pic,A1
    247. 

  247.         MOVEA.L tags,A2
    248. 

  248.         MOVEA.L GuiGFXBase,A6
    249. 

  249.         JSR     -066(A6)
    250. 

  250.         MOVEA.L (A7)+,A6
    251. 

  251.         MOVE.L  D0,@RESULT
    252. 

  252.   END;
    253. 

  253. END;
    254. 

  254. 

  255. FUNCTION AddPixelArrayA(psm : POINTER; _array : POINTER; width : WORD; height : WORD; tags : pTagItem) : POINTER;
    256. 

  256. BEGIN
    257. 

  257.   ASM
    258. 

  258.         MOVE.L  A6,-(A7)
    259. 

  259.         MOVEA.L psm,A0
    260. 

  260.         MOVEA.L _array,A1
    261. 

  261.         MOVE.L  width,D0
    262. 

  262.         MOVE.L  height,D1
    263. 

  263.         MOVEA.L tags,A2
    264. 

  264.         MOVEA.L GuiGFXBase,A6
    265. 

  265.         JSR     -078(A6)
    266. 

  266.         MOVEA.L (A7)+,A6
    267. 

  267.         MOVE.L  D0,@RESULT
    268. 

  268.   END;
    269. 

  269. END;
    270. 

  270. 

  271. FUNCTION ClonePictureA(pic : POINTER; tags : pTagItem) : POINTER;
    272. 

  272. BEGIN
    273. 

  273.   ASM
    274. 

  274.         MOVE.L  A6,-(A7)
    275. 

  275.         MOVEA.L pic,A0
    276. 

  276.         MOVEA.L tags,A1
    277. 

  277.         MOVEA.L GuiGFXBase,A6
    278. 

  278.         JSR     -048(A6)
    279. 

  279.         MOVEA.L (A7)+,A6
    280. 

  280.         MOVE.L  D0,@RESULT
    281. 

  281.   END;
    282. 

  282. END;
    283. 

  283. 

  284. FUNCTION CreateDirectDrawHandleA(drawhandle : POINTER; sw : WORD; sh : WORD; dw : WORD; dh : WORD; tags : pTagItem) : POINTER;
    285. 

  285. BEGIN
    286. 

  286.   ASM
    287. 

  287.         MOVE.L  A6,-(A7)
    288. 

  288.         MOVEA.L drawhandle,A0
    289. 

  289.         MOVE.L  sw,D0
    290. 

  290.         MOVE.L  sh,D1
    291. 

  291.         MOVE.L  dw,D2
    292. 

  292.         MOVE.L  dh,D3
    293. 

  293.         MOVEA.L tags,A1
    294. 

  294.         MOVEA.L GuiGFXBase,A6
    295. 

  295.         JSR     -168(A6)
    296. 

  296.         MOVEA.L (A7)+,A6
    297. 

  297.         MOVE.L  D0,@RESULT
    298. 

  298.   END;
    299. 

  299. END;
    300. 

  300. 

  301. FUNCTION CreatePenShareMapA(tags : pTagItem) : POINTER;
    302. 

  302. BEGIN
    303. 

  303.   ASM
    304. 

  304.         MOVE.L  A6,-(A7)
    305. 

  305.         MOVEA.L tags,A0
    306. 

  306.         MOVEA.L GuiGFXBase,A6
    307. 

  307.         JSR     -090(A6)
    308. 

  308.         MOVEA.L (A7)+,A6
    309. 

  309.         MOVE.L  D0,@RESULT
    310. 

  310.   END;
    311. 

  311. END;
    312. 

  312. 

  313. FUNCTION CreatePictureBitMapA(drawhandle : POINTER; pic : POINTER; tags : pTagItem) : pBitMap;
    314. 

  314. BEGIN
    315. 

  315.   ASM
    316. 

  316.         MOVE.L  A6,-(A7)
    317. 

  317.         MOVEA.L drawhandle,A0
    318. 

  318.         MOVEA.L pic,A1
    319. 

  319.         MOVEA.L tags,A2
    320. 

  320.         MOVEA.L GuiGFXBase,A6
    321. 

  321.         JSR     -132(A6)
    322. 

  322.         MOVEA.L (A7)+,A6
    323. 

  323.         MOVE.L  D0,@RESULT
    324. 

  324.   END;
    325. 

  325. END;
    326. 

  326. 

  327. FUNCTION CreatePictureMaskA(pic : POINTER; mask : pCHAR; maskwidth : WORD; tags : pTagItem) : BOOLEAN;
    328. 

  328. BEGIN
    329. 

  329.   ASM
    330. 

  330.         MOVE.L  A6,-(A7)
    331. 

  331.         MOVEA.L pic,A0
    332. 

  332.         MOVEA.L mask,A1
    333. 

  333.         MOVE.L  maskwidth,D0
    334. 

  334.         MOVEA.L tags,A2
    335. 

  335.         MOVEA.L GuiGFXBase,A6
    336. 

  336.         JSR     -186(A6)
    337. 

  337.         MOVEA.L (A7)+,A6
    338. 

  338.         TST.W   D0
    339. 

  339.         BEQ.B   @end
    340. 

  340.         MOVEQ   #1,D0
    341. 

  341.   @end: MOVE.B  D0,@RESULT
    342. 

  342.   END;
    343. 

  343. END;
    344. 

  344. 

  345. PROCEDURE DeleteDirectDrawHandle(ddh : POINTER);
    346. 

  346. BEGIN
    347. 

  347.   ASM
    348. 

  348.         MOVE.L  A6,-(A7)
    349. 

  349.         MOVEA.L ddh,A0
    350. 

  350.         MOVEA.L GuiGFXBase,A6
    351. 

  351.         JSR     -174(A6)
    352. 

  352.         MOVEA.L (A7)+,A6
    353. 

  353.   END;
    354. 

  354. END;
    355. 

  355. 

  356. PROCEDURE DeletePenShareMap(psm : POINTER);
    357. 

  357. BEGIN
    358. 

  358.   ASM
    359. 

  359.         MOVE.L  A6,-(A7)
    360. 

  360.         MOVEA.L psm,A0
    361. 

  361.         MOVEA.L GuiGFXBase,A6
    362. 

  362.         JSR     -096(A6)
    363. 

  363.         MOVEA.L (A7)+,A6
    364. 

  364.   END;
    365. 

  365. END;
    366. 

  366. 

  367. PROCEDURE DeletePicture(pic : POINTER);
    368. 

  368. BEGIN
    369. 

  369.   ASM
    370. 

  370.         MOVE.L  A6,-(A7)
    371. 

  371.         MOVEA.L pic,A0
    372. 

  372.         MOVEA.L GuiGFXBase,A6
    373. 

  373.         JSR     -054(A6)
    374. 

  374.         MOVEA.L (A7)+,A6
    375. 

  375.   END;
    376. 

  376. END;
    377. 

  377. 

  378. FUNCTION DirectDrawTrueColorA(ddh : POINTER; _array : pULONG; x : WORD; y : WORD; tags : pTagItem) : BOOLEAN;
    379. 

  379. BEGIN
    380. 

  380.   ASM
    381. 

  381.         MOVE.L  A6,-(A7)
    382. 

  382.         MOVEA.L ddh,A0
    383. 

  383.         MOVEA.L _array,A1
    384. 

  384.         MOVE.L  x,D0
    385. 

  385.         MOVE.L  y,D1
    386. 

  386.         MOVEA.L tags,A2
    387. 

  387.         MOVEA.L GuiGFXBase,A6
    388. 

  388.         JSR     -180(A6)
    389. 

  389.         MOVEA.L (A7)+,A6
    390. 

  390.         TST.W   D0
    391. 

  391.         BEQ.B   @end
    392. 

  392.         MOVEQ   #1,D0
    393. 

  393.   @end: MOVE.B  D0,@RESULT
    394. 

  394.   END;
    395. 

  395. END;
    396. 

  396. 

  397. FUNCTION DoPictureMethodA(pic : POINTER; method : longword; arguments : pULONG) : longword;
    398. 

  398. BEGIN
    399. 

  399.   ASM
    400. 

  400.         MOVE.L  A6,-(A7)
    401. 

  401.         MOVEA.L pic,A0
    402. 

  402.         MOVE.L  method,D0
    403. 

  403.         MOVEA.L arguments,A1
    404. 

  404.         MOVEA.L GuiGFXBase,A6
    405. 

  405.         JSR     -138(A6)
    406. 

  406.         MOVEA.L (A7)+,A6
    407. 

  407.         MOVE.L  D0,@RESULT
    408. 

  408.   END;
    409. 

  409. END;
    410. 

  410. 

  411. FUNCTION DrawPictureA(drawhandle : POINTER; pic : POINTER; x : WORD; y : WORD; tags : pTagItem) : BOOLEAN;
    412. 

  412. BEGIN
    413. 

  413.   ASM
    414. 

  414.         MOVE.L  A6,-(A7)
    415. 

  415.         MOVEA.L drawhandle,A0
    416. 

  416.         MOVEA.L pic,A1
    417. 

  417.         MOVE.L  x,D0
    418. 

  418.         MOVE.L  y,D1
    419. 

  419.         MOVEA.L tags,A2
    420. 

  420.         MOVEA.L GuiGFXBase,A6
    421. 

  421.         JSR     -114(A6)
    422. 

  422.         MOVEA.L (A7)+,A6
    423. 

  423.         TST.W   D0
    424. 

  424.         BEQ.B   @end
    425. 

  425.         MOVEQ   #1,D0
    426. 

  426.   @end: MOVE.B  D0,@RESULT
    427. 

  427.   END;
    428. 

  428. END;
    429. 

  429. 

  430. FUNCTION GetPictureAttrsA(pic : POINTER; tags : pTagItem) : longword;
    431. 

  431. BEGIN
    432. 

  432.   ASM
    433. 

  433.         MOVE.L  A6,-(A7)
    434. 

  434.         MOVEA.L pic,A0
    435. 

  435.         MOVEA.L tags,A1
    436. 

  436.         MOVEA.L GuiGFXBase,A6
    437. 

  437.         JSR     -144(A6)
    438. 

  438.         MOVEA.L (A7)+,A6
    439. 

  439.         MOVE.L  D0,@RESULT
    440. 

  440.   END;
    441. 

  441. END;
    442. 

  442. 

  443. FUNCTION IsPictureA(filename : pCHAR; tags : pTagItem) : BOOLEAN;
    444. 

  444. BEGIN
    445. 

  445.   ASM
    446. 

  446.         MOVE.L  A6,-(A7)
    447. 

  447.         MOVEA.L filename,A0
    448. 

  448.         MOVEA.L tags,A1
    449. 

  449.         MOVEA.L GuiGFXBase,A6
    450. 

  450.         JSR     -162(A6)
    451. 

  451.         MOVEA.L (A7)+,A6
    452. 

  452.         TST.W   D0
    453. 

  453.         BEQ.B   @end
    454. 

  454.         MOVEQ   #1,D0
    455. 

  455.   @end: MOVE.B  D0,@RESULT
    456. 

  456.   END;
    457. 

  457. END;
    458. 

  458. 

  459. FUNCTION LoadPictureA(filename : pCHAR; tags : pTagItem) : POINTER;
    460. 

  460. BEGIN
    461. 

  461.   ASM
    462. 

  462.         MOVE.L  A6,-(A7)
    463. 

  463.         MOVEA.L filename,A0
    464. 

  464.         MOVEA.L tags,A1
    465. 

  465.         MOVEA.L GuiGFXBase,A6
    466. 

  466.         JSR     -036(A6)
    467. 

  467.         MOVEA.L (A7)+,A6
    468. 

  468.         MOVE.L  D0,@RESULT
    469. 

  469.   END;
    470. 

  470. END;
    471. 

  471. 

  472. FUNCTION LockPictureA(pic : POINTER; mode : longword; args : pULONG) : longword;
    473. 

  473. BEGIN
    474. 

  474.   ASM
    475. 

  475.         MOVE.L  A6,-(A7)
    476. 

  476.         MOVEA.L pic,A0
    477. 

  477.         MOVE.L  mode,D0
    478. 

  478.         MOVEA.L args,A1
    479. 

  479.         MOVEA.L GuiGFXBase,A6
    480. 

  480.         JSR     -150(A6)
    481. 

  481.         MOVEA.L (A7)+,A6
    482. 

  482.         MOVE.L  D0,@RESULT
    483. 

  483.   END;
    484. 

  484. END;
    485. 

  485. 

  486. FUNCTION MakePictureA(_array : POINTER; width : WORD; height : WORD; tags : pTagItem) : POINTER;
    487. 

  487. BEGIN
    488. 

  488.   ASM
    489. 

  489.         MOVE.L  A6,-(A7)
    490. 

  490.         MOVEA.L _array,A0
    491. 

  491.         MOVE.L  width,D0
    492. 

  492.         MOVE.L  height,D1
    493. 

  493.         MOVEA.L tags,A1
    494. 

  494.         MOVEA.L GuiGFXBase,A6
    495. 

  495.         JSR     -030(A6)
    496. 

  496.         MOVEA.L (A7)+,A6
    497. 

  497.         MOVE.L  D0,@RESULT
    498. 

  498.   END;
    499. 

  499. END;
    500. 

  500. 

  501. FUNCTION MapPaletteA(drawhandle : POINTER; palette : POINTER; pentab : pCHAR; tags : pTagItem) : BOOLEAN;
    502. 

  502. BEGIN
    503. 

  503.   ASM
    504. 

  504.         MOVE.L  A6,-(A7)
    505. 

  505.         MOVEA.L drawhandle,A0
    506. 

  506.         MOVEA.L palette,A1
    507. 

  507.         MOVEA.L pentab,A2
    508. 

  508.         MOVEA.L tags,A3
    509. 

  509.         MOVEA.L GuiGFXBase,A6
    510. 

  510.         JSR     -120(A6)
    511. 

  511.         MOVEA.L (A7)+,A6
    512. 

  512.         TST.W   D0
    513. 

  513.         BEQ.B   @end
    514. 

  514.         MOVEQ   #1,D0
    515. 

  515.   @end: MOVE.B  D0,@RESULT
    516. 

  516.   END;
    517. 

  517. END;
    518. 

  518. 

  519. FUNCTION MapPenA(drawhandle : POINTER; rgb : longword; tags : pTagItem) : LONGINT;
    520. 

  520. BEGIN
    521. 

  521.   ASM
    522. 

  522.         MOVE.L  A6,-(A7)
    523. 

  523.         MOVEA.L drawhandle,A0
    524. 

  524.         MOVEA.L rgb,A1
    525. 

  525.         MOVEA.L tags,A2
    526. 

  526.         MOVEA.L GuiGFXBase,A6
    527. 

  527.         JSR     -126(A6)
    528. 

  528.         MOVEA.L (A7)+,A6
    529. 

  529.         MOVE.L  D0,@RESULT
    530. 

  530.   END;
    531. 

  531. END;
    532. 

  532. 

  533. FUNCTION ObtainDrawHandleA(psm : POINTER; a1arg : pRastPort; cm : pColorMap; tags : pTagItem) : POINTER;
    534. 

  534. BEGIN
    535. 

  535.   ASM
    536. 

  536.         MOVE.L  A6,-(A7)
    537. 

  537.         MOVEA.L psm,A0
    538. 

  538.         MOVEA.L a1arg,A1
    539. 

  539.         MOVEA.L cm,A2
    540. 

  540.         MOVEA.L tags,A3
    541. 

  541.         MOVEA.L GuiGFXBase,A6
    542. 

  542.         JSR     -102(A6)
    543. 

  543.         MOVEA.L (A7)+,A6
    544. 

  544.         MOVE.L  D0,@RESULT
    545. 

  545.   END;
    546. 

  546. END;
    547. 

  547. 

  548. FUNCTION ReadPictureA(a0arg : pRastPort; colormap : pColorMap; x : WORD; y : WORD; width : WORD; height : WORD; tags : pTagItem) : POINTER;
    549. 

  549. BEGIN
    550. 

  550.   ASM
    551. 

  551.         MOVE.L  A6,-(A7)
    552. 

  552.         MOVEA.L a0arg,A0
    553. 

  553.         MOVEA.L colormap,A1
    554. 

  554.         MOVE.L  x,D0
    555. 

  555.         MOVE.L  y,D1
    556. 

  556.         MOVE.L  width,D2
    557. 

  557.         MOVE.L  height,D3
    558. 

  558.         MOVEA.L tags,A2
    559. 

  559.         MOVEA.L GuiGFXBase,A6
    560. 

  560.         JSR     -042(A6)
    561. 

  561.         MOVEA.L (A7)+,A6
    562. 

  562.         MOVE.L  D0,@RESULT
    563. 

  563.   END;
    564. 

  564. END;
    565. 

  565. 

  566. PROCEDURE ReleaseDrawHandle(drawhandle : POINTER);
    567. 

  567. BEGIN
    568. 

  568.   ASM
    569. 

  569.         MOVE.L  A6,-(A7)
    570. 

  570.         MOVEA.L drawhandle,A0
    571. 

  571.         MOVEA.L GuiGFXBase,A6
    572. 

  572.         JSR     -108(A6)
    573. 

  573.         MOVEA.L (A7)+,A6
    574. 

  574.   END;
    575. 

  575. END;
    576. 

  576. 

  577. PROCEDURE RemColorHandle(colorhandle : POINTER);
    578. 

  578. BEGIN
    579. 

  579.   ASM
    580. 

  580.         MOVE.L  A6,-(A7)
    581. 

  581.         MOVEA.L colorhandle,A0
    582. 

  582.         MOVEA.L GuiGFXBase,A6
    583. 

  583.         JSR     -084(A6)
    584. 

  584.         MOVEA.L (A7)+,A6
    585. 

  585.   END;
    586. 

  586. END;
    587. 

  587. 

  588. PROCEDURE UnLockPicture(pic : POINTER; mode : longword);
    589. 

  589. BEGIN
    590. 

  590.   ASM
    591. 

  591.         MOVE.L  A6,-(A7)
    592. 

  592.         MOVEA.L pic,A0
    593. 

  593.         MOVE.L  mode,D0
    594. 

  594.         MOVEA.L GuiGFXBase,A6
    595. 

  595.         JSR     -156(A6)
    596. 

  596.         MOVEA.L (A7)+,A6
    597. 

  597.   END;
    598. 

  598. END;
    599. 

  599. 

  600. {
    601. 

  601.  Functions and procedures with array of const go here
    602. 

  602. }
    603. 

  603. FUNCTION AddPalette(psm : POINTER; palette : POINTER; const tags : Array Of Const) : POINTER;
    604. 

  604. begin
    605. 

  605.     AddPalette := AddPaletteA(psm , palette , readintags(tags));
    606. 

  606. end;
    607. 

  607. 

  608. FUNCTION AddPicture(psm : POINTER; pic : POINTER; const tags : Array Of Const) : POINTER;
    609. 

  609. begin
    610. 

  610.     AddPicture := AddPictureA(psm , pic , readintags(tags));
    611. 

  611. end;
    612. 

  612. 

  613. FUNCTION AddPixelArray(psm : POINTER; _array : POINTER; width : WORD; height : WORD; const tags : Array Of Const) : POINTER;
    614. 

  614. begin
    615. 

  615.     AddPixelArray := AddPixelArrayA(psm , _array , width , height , readintags(tags));
    616. 

  616. end;
    617. 

  617. 

  618. FUNCTION ClonePicture(pic : POINTER; const tags : Array Of Const) : POINTER;
    619. 

  619. begin
    620. 

  620.     ClonePicture := ClonePictureA(pic , readintags(tags));
    621. 

  621. end;
    622. 

  622. 

  623. FUNCTION CreateDirectDrawHandle(drawhandle : POINTER; sw : WORD; sh : WORD; dw : WORD; dh : WORD; const tags : Array Of Const) : POINTER;
    624. 

  624. begin
    625. 

  625.     CreateDirectDrawHandle := CreateDirectDrawHandleA(drawhandle , sw , sh , dw , dh , readintags(tags));
    626. 

  626. end;
    627. 

  627. 

  628. FUNCTION CreatePenShareMap(const tags : Array Of Const) : POINTER;
    629. 

  629. begin
    630. 

  630.     CreatePenShareMap := CreatePenShareMapA(readintags(tags));
    631. 

  631. end;
    632. 

  632. 

  633. FUNCTION CreatePictureBitMap(drawhandle : POINTER; pic : POINTER; const tags : Array Of Const) : pBitMap;
    634. 

  634. begin
    635. 

  635.     CreatePictureBitMap := CreatePictureBitMapA(drawhandle , pic , readintags(tags));
    636. 

  636. end;
    637. 

  637. 

  638. FUNCTION CreatePictureMask(pic : POINTER; mask : pCHAR; maskwidth : WORD; const tags : Array Of Const) : BOOLEAN;
    639. 

  639. begin
    640. 

  640.     CreatePictureMask := CreatePictureMaskA(pic , mask , maskwidth , readintags(tags));
    641. 

  641. end;
    642. 

  642. 

  643. FUNCTION DirectDrawTrueColor(ddh : POINTER; _array : pULONG; x : WORD; y : WORD; const tags : Array Of Const) : BOOLEAN;
    644. 

  644. begin
    645. 

  645.     DirectDrawTrueColor := DirectDrawTrueColorA(ddh , _array , x , y , readintags(tags));
    646. 

  646. end;
    647. 

  647. 

  648. FUNCTION DoPictureMethod(pic : POINTER; method : longword; const arguments : Array Of Const) : longword;
    649. 

  649. begin
    650. 

  650.     DoPictureMethod := DoPictureMethodA(pic , method , readinlongs(arguments));
    651. 

  651. end;
    652. 

  652. 

  653. FUNCTION DrawPicture(drawhandle : POINTER; pic : POINTER; x : WORD; y : WORD; const tags : Array Of Const) : BOOLEAN;
    654. 

  654. begin
    655. 

  655.     DrawPicture := DrawPictureA(drawhandle , pic , x , y , readintags(tags));
    656. 

  656. end;
    657. 

  657. 

  658. FUNCTION GetPictureAttrs(pic : POINTER; const tags : Array Of Const) : longword;
    659. 

  659. begin
    660. 

  660.     GetPictureAttrs := GetPictureAttrsA(pic , readintags(tags));
    661. 

  661. end;
    662. 

  662. 

  663. FUNCTION IsPicture(filename : pCHAR; const tags : Array Of Const) : BOOLEAN;
    664. 

  664. begin
    665. 

  665.     IsPicture := IsPictureA(filename , readintags(tags));
    666. 

  666. end;
    667. 

  667. 

  668. FUNCTION LoadPicture(filename : pCHAR; const tags : Array Of Const) : POINTER;
    669. 

  669. begin
    670. 

  670.     LoadPicture := LoadPictureA(filename , readintags(tags));
    671. 

  671. end;
    672. 

  672. 

  673. FUNCTION LockPicture(pic : POINTER; mode : longword; const args : Array Of Const) : longword;
    674. 

  674. begin
    675. 

  675.     LockPicture := LockPictureA(pic , mode , readinlongs(args));
    676. 

  676. end;
    677. 

  677. 

  678. FUNCTION MakePicture(_array : POINTER; width : WORD; height : WORD; const tags : Array Of Const) : POINTER;
    679. 

  679. begin
    680. 

  680.     MakePicture := MakePictureA(_array , width , height , readintags(tags));
    681. 

  681. end;
    682. 

  682. 

  683. FUNCTION MapPalette(drawhandle : POINTER; palette : POINTER; pentab : pCHAR; const tags : Array Of Const) : BOOLEAN;
    684. 

  684. begin
    685. 

  685.     MapPalette := MapPaletteA(drawhandle , palette , pentab , readintags(tags));
    686. 

  686. end;
    687. 

  687. 

  688. FUNCTION MapPen(drawhandle : POINTER; rgb : longword; const tags : Array Of Const) : LONGINT;
    689. 

  689. begin
    690. 

  690.     MapPen := MapPenA(drawhandle , rgb , readintags(tags));
    691. 

  691. end;
    692. 

  692. 

  693. FUNCTION ObtainDrawHandle(psm : POINTER; a1arg : pRastPort; cm : pColorMap; const tags : Array Of Const) : POINTER;
    694. 

  694. begin
    695. 

  695.     ObtainDrawHandle := ObtainDrawHandleA(psm , a1arg , cm , readintags(tags));
    696. 

  696. end;
    697. 

  697. 

  698. FUNCTION ReadPicture(a0arg : pRastPort; colormap : pColorMap; x : WORD; y : WORD; width : WORD; height : WORD; const tags : Array Of Const) : POINTER;
    699. 

  699. begin
    700. 

  700.     ReadPicture := ReadPictureA(a0arg , colormap , x , y , width , height , readintags(tags));
    701. 

  701. end;
    702. 

  702. 

  703. const
    704. 

  704.     { Change VERSION and LIBVERSION to proper values }
    705. 

  705. 

  706.     VERSION : string[2] = '0';
    707. 

  707.     LIBVERSION : longword = 0;
    708. 

  708. 

  709. {$ifdef use_init_openlib}
    710. 

  710.   {$Info Compiling initopening of guigfx.library}
    711. 

  711.   {$Info don't forget to use InitGUIGFXLibrary in the beginning of your program}
    712. 

    713. 

  713. var
    714. 

  714.     guigfx_exit : Pointer;
    715. 

  715. 

  716. procedure CloseguigfxLibrary;
    717. 

  717. begin
    718. 

  718.     ExitProc := guigfx_exit;
    719. 

  719.     if GuiGFXBase <> nil then begin
    720. 

  720.         CloseLibrary(GuiGFXBase);
    721. 

  721.         GuiGFXBase := nil;
    722. 

  722.     end;
    723. 

  723. end;
    724. 

  724. 

  725. procedure InitGUIGFXLibrary;
    726. 

  726. begin
    727. 

  727.     GuiGFXBase := nil;
    728. 

  728.     GuiGFXBase := OpenLibrary(GUIGFXNAME,LIBVERSION);
    729. 

  729.     if GuiGFXBase <> nil then begin
    730. 

  730.         guigfx_exit := ExitProc;
    731. 

  731.         ExitProc := @CloseguigfxLibrary;
    732. 

  732.     end else begin
    733. 

  733.         MessageBox('FPC Pascal Error',
    734. 

  734.         'Can''t open guigfx.library version ' + VERSION + #10 +
    735. 

  735.         'Deallocating resources and closing down',
    736. 

  736.         'Oops');
    737. 

  737.         halt(20);
    738. 

  738.     end;
    739. 

  739. end;
    740. 

  740. 

  741. begin
    742. 

  742.     GUIGFXIsCompiledHow := 2;
    743. 

  743. {$endif use_init_openlib}
    744. 

  744. 

  745. {$ifdef use_auto_openlib}
    746. 

  746.   {$Info Compiling autoopening of guigfx.library}
    747. 

  747. 

  748. var
    749. 

  749.     guigfx_exit : Pointer;
    750. 

  750. 

  751. procedure CloseguigfxLibrary;
    752. 

  752. begin
    753. 

  753.     ExitProc := guigfx_exit;
    754. 

  754.     if GuiGFXBase <> nil then begin
    755. 

  755.         CloseLibrary(GuiGFXBase);
    756. 

  756.         GuiGFXBase := nil;
    757. 

  757.     end;
    758. 

  758. end;
    759. 

  759. 

  760. begin
    761. 

  761.     GuiGFXBase := nil;
    762. 

  762.     GuiGFXBase := OpenLibrary(GUIGFXNAME,LIBVERSION);
    763. 

  763.     if GuiGFXBase <> nil then begin
    764. 

  764.         guigfx_exit := ExitProc;
    765. 

  765.         ExitProc := @CloseguigfxLibrary;
    766. 

  766.         GUIGFXIsCompiledHow := 1;
    767. 

  767.     end else begin
    768. 

  768.         MessageBox('FPC Pascal Error',
    769. 

  769.         'Can''t open guigfx.library version ' + VERSION + #10 +
    770. 

  770.         'Deallocating resources and closing down',
    771. 

  771.         'Oops');
    772. 

  772.         halt(20);
    773. 

  773.     end;
    774. 

  774. 

  775. {$endif use_auto_openlib}
    776. 

  776. 

  777. {$ifdef dont_use_openlib}
    778. 

  778. begin
    779. 

  779.     GUIGFXIsCompiledHow := 3;
    780. 

  780.    {$Warning No autoopening of guigfx.library compiled}
    781. 

  781.    {$Warning Make sure you open guigfx.library yourself}
    782. 

  782. {$endif dont_use_openlib}
    783. 

  783. 

  784. END. (* UNIT GUIGFX *)
    785.