/packages/amunits/src/coreunits/layers.pas

https://github.com/slibre/freepascal · Pascal · 657 lines · 529 code · 65 blank · 63 comment · 6 complexity · 8aecdf8ea9f3ff982ebce37b5c1c0de3 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) 1998-2003 by Nils Sjoholm
    6. 

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

  7. 

  8.     See the file COPYING.FPC, included in this distribution,
    9. 

  9.     for details about the copyright.
    10. 

  10. 

  11.     This program is distributed in the hope that it will be useful,
    12. 

  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    14. 

  14. 

  15.  **********************************************************************}
    16. 

  16. {
    17. 

  17.     History:
    18. 

  18. 

  19.     Added the defines use_amiga_smartlink and
    20. 

  20.     use_auto_openlib. Implemented autoopening
    21. 

  21.     of the library.
    22. 

  22.     14 Jan 2003.
    23. 

  23. 

  24.     Update for AmigaOS 3.9.
    25. 

  25.     Changed start code for unit.
    26. 

  26.     06 Feb 2003.
    27. 

  27. 

  28.     Changed integer > smallint,
    29. 

  29.             cardinal > longword.
    30. 

  30.     09 Feb 2003.
    31. 

  31. 

  32.     nils.sjoholm@mailbox.swipnet.se
    33. 

  33. }
    34. 

  34. 

  35. {$I useamigasmartlink.inc}
    36. 

  36. {$ifdef use_amiga_smartlink}
    37. 

  37.    {$smartlink on}
    38. 

  38. {$endif use_amiga_smartlink}
    39. 

  39. 

  40. UNIT layers;
    41. 

  41. 

  42. INTERFACE
    43. 

  43. USES exec, graphics, utility;
    44. 

  44. 

  45. const
    46. 

  46. 

  47.     LAYERSIMPLE         = 1;
    48. 

  48.     LAYERSMART          = 2;
    49. 

  49.     LAYERSUPER          = 4;
    50. 

  50.     LAYERUPDATING       = $10;
    51. 

  51.     LAYERBACKDROP       = $40;
    52. 

  52.     LAYERREFRESH        = $80;
    53. 

  53.     LAYER_CLIPRECTS_LOST = $100;        { during BeginUpdate }
    54. 

  54.                                         { or during layerop }
    55. 

  55.                                         { this happens if out of memory }
    56. 

  56.     LMN_REGION          = -1;
    57. 

  57. 

  58. type
    59. 

  59.  pLayer_Info = ^tLayer_Info;
    60. 

  60.  tLayer_Info = record
    61. 

  61.     top_layer           : pLayer;
    62. 

  62.     check_lp            : pLayer;              { !! Private !! }
    63. 

  63.     obs                 : pClipRect;
    64. 

  64.     FreeClipRects       : pClipRect;              { !! Private !! }
    65. 

  65.     PrivateReserve1,                            { !! Private !! }
    66. 

  66.     PrivateReserve2     : Longint;              { !! Private !! }
    67. 

  67.     Lock                : tSignalSemaphore;      { !! Private !! }
    68. 

  68.     gs_Head             : tMinList;              { !! Private !! }
    69. 

  69.     PrivateReserve3     : smallint;                 { !! Private !! }
    70. 

  70.     PrivateReserve4     : Pointer;              { !! Private !! }
    71. 

  71.     Flags               : WORD;
    72. 

  72.     fatten_count        : Shortint;                 { !! Private !! }
    73. 

  73.     LockLayersCount     : Shortint;                 { !! Private !! }
    74. 

  74.     PrivateReserve5     : smallint;                 { !! Private !! }
    75. 

  75.     BlankHook,                                  { !! Private !! }
    76. 

  76.     LayerInfo_extra     : Pointer;              { !! Private !! }
    77. 

  77.  end;
    78. 

  78. 

  79. const
    80. 

  80.     NEWLAYERINFO_CALLED = 1;
    81. 

  81. 

  82. {
    83. 

  83.  * LAYERS_NOBACKFILL is the value needed to get no backfill hook
    84. 

  84.  * LAYERS_BACKFILL is the value needed to get the default backfill hook
    85. 

  85.  }
    86. 

  86.  LAYERS_NOBACKFILL      = 1;
    87. 

  87.  LAYERS_BACKFILL        = 0;
    88. 

  88. 

  89.  LAYERSNAME : PChar = 'layers.library';
    90. 

  90. 

  91. VAR LayersBase : pLibrary;
    92. 

  92. 

  93. FUNCTION BeginUpdate(l : pLayer) : LONGINT;
    94. 

  94. FUNCTION BehindLayer(dummy : LONGINT; layer : pLayer) : LONGINT;
    95. 

  95. FUNCTION CreateBehindHookLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; hook : pHook; bm2 : pBitMap) : pLayer;
    96. 

  96. FUNCTION CreateBehindLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; bm2 : pBitMap) : pLayer;
    97. 

  97. FUNCTION CreateUpfrontHookLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; hook : pHook; bm2 : pBitMap) : pLayer;
    98. 

  98. FUNCTION CreateUpfrontLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; bm2 : pBitMap) : pLayer;
    99. 

  99. FUNCTION DeleteLayer(dummy : LONGINT; layer : pLayer) : LONGINT;
    100. 

  100. PROCEDURE DisposeLayerInfo(li : pLayer_Info);
    101. 

  101. PROCEDURE DoHookClipRects(hook : pHook; rport : pRastPort;const rect : pRectangle);
    102. 

  102. PROCEDURE EndUpdate(layer : pLayer; flag : ULONG);
    103. 

  103. FUNCTION FattenLayerInfo(li : pLayer_Info) : LONGINT;
    104. 

  104. PROCEDURE InitLayers(li : pLayer_Info);
    105. 

  105. FUNCTION InstallClipRegion(layer : pLayer;const region : pRegion) : pRegion;
    106. 

  106. FUNCTION InstallLayerHook(layer : pLayer; hook : pHook) : pHook;
    107. 

  107. FUNCTION InstallLayerInfoHook(li : pLayer_Info;const hook : pHook) : pHook;
    108. 

  108. PROCEDURE LockLayer(dummy : LONGINT; layer : pLayer);
    109. 

  109. PROCEDURE LockLayerInfo(li : pLayer_Info);
    110. 

  110. PROCEDURE LockLayers(li : pLayer_Info);
    111. 

  111. FUNCTION MoveLayer(dummy : LONGINT; layer : pLayer; dx : LONGINT; dy : LONGINT) : LONGINT;
    112. 

  112. FUNCTION MoveLayerInFrontOf(layer_to_move : pLayer; other_layer : pLayer) : LONGINT;
    113. 

  113. FUNCTION MoveSizeLayer(layer : pLayer; dx : LONGINT; dy : LONGINT; dw : LONGINT; dh : LONGINT) : LONGINT;
    114. 

  114. FUNCTION NewLayerInfo : pLayer_Info;
    115. 

  115. PROCEDURE ScrollLayer(dummy : LONGINT; layer : pLayer; dx : LONGINT; dy : LONGINT);
    116. 

  116. FUNCTION SizeLayer(dummy : LONGINT; layer : pLayer; dx : LONGINT; dy : LONGINT) : LONGINT;
    117. 

  117. PROCEDURE SortLayerCR(layer : pLayer; dx : LONGINT; dy : LONGINT);
    118. 

  118. PROCEDURE SwapBitsRastPortClipRect(rp : pRastPort; cr : pClipRect);
    119. 

  119. PROCEDURE ThinLayerInfo(li : pLayer_Info);
    120. 

  120. PROCEDURE UnlockLayer(layer : pLayer);
    121. 

  121. PROCEDURE UnlockLayerInfo(li : pLayer_Info);
    122. 

  122. PROCEDURE UnlockLayers(li : pLayer_Info);
    123. 

  123. FUNCTION UpfrontLayer(dummy : LONGINT; layer : pLayer) : LONGINT;
    124. 

  124. FUNCTION WhichLayer(li : pLayer_Info; x : LONGINT; y : LONGINT) : pLayer;
    125. 

  125. 

  126. {Here we read how to compile this unit}
    127. 

  127. {You can remove this include and use a define instead}
    128. 

  128. {$I useautoopenlib.inc}
    129. 

  129. {$ifdef use_init_openlib}
    130. 

  130. procedure InitLAYERSLibrary;
    131. 

  131. {$endif use_init_openlib}
    132. 

  132. 

  133. {This is a variable that knows how the unit is compiled}
    134. 

  134. var
    135. 

  135.     LAYERSIsCompiledHow : longint;
    136. 

  136. 

  137. IMPLEMENTATION
    138. 

  138. 

  139. uses
    140. 

  140. {$ifndef dont_use_openlib}
    141. 

  141. msgbox;
    142. 

  142. {$endif dont_use_openlib}
    143. 

  143. 

  144. FUNCTION BeginUpdate(l : pLayer) : LONGINT;
    145. 

  145. BEGIN
    146. 

  146.   ASM
    147. 

  147.     MOVE.L  A6,-(A7)
    148. 

  148.     MOVEA.L l,A0
    149. 

  149.     MOVEA.L LayersBase,A6
    150. 

  150.     JSR -078(A6)
    151. 

  151.     MOVEA.L (A7)+,A6
    152. 

  152.     MOVE.L  D0,@RESULT
    153. 

  153.   END;
    154. 

  154. END;
    155. 

  155. 

  156. FUNCTION BehindLayer(dummy : LONGINT; layer : pLayer) : LONGINT;
    157. 

  157. BEGIN
    158. 

  158.   ASM
    159. 

  159.     MOVE.L  A6,-(A7)
    160. 

  160.     MOVEA.L dummy,A0
    161. 

  161.     MOVEA.L layer,A1
    162. 

  162.     MOVEA.L LayersBase,A6
    163. 

  163.     JSR -054(A6)
    164. 

  164.     MOVEA.L (A7)+,A6
    165. 

  165.     MOVE.L  D0,@RESULT
    166. 

  166.   END;
    167. 

  167. END;
    168. 

  168. 

  169. FUNCTION CreateBehindHookLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; hook : pHook; bm2 : pBitMap) : pLayer;
    170. 

  170. BEGIN
    171. 

  171.   ASM
    172. 

  172.     MOVE.L  A6,-(A7)
    173. 

  173.     MOVEA.L li,A0
    174. 

  174.     MOVEA.L bm,A1
    175. 

  175.     MOVE.L  x0,D0
    176. 

  176.     MOVE.L  y0,D1
    177. 

  177.     MOVE.L  x1,D2
    178. 

  178.     MOVE.L  y1,D3
    179. 

  179.     MOVE.L  flags,D4
    180. 

  180.     MOVEA.L hook,A3
    181. 

  181.     MOVEA.L bm2,A2
    182. 

  182.     MOVEA.L LayersBase,A6
    183. 

  183.     JSR -192(A6)
    184. 

  184.     MOVEA.L (A7)+,A6
    185. 

  185.     MOVE.L  D0,@RESULT
    186. 

  186.   END;
    187. 

  187. END;
    188. 

  188. 

  189. FUNCTION CreateBehindLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; bm2 : pBitMap) : pLayer;
    190. 

  190. BEGIN
    191. 

  191.   ASM
    192. 

  192.     MOVE.L  A6,-(A7)
    193. 

  193.     MOVEA.L li,A0
    194. 

  194.     MOVEA.L bm,A1
    195. 

  195.     MOVE.L  x0,D0
    196. 

  196.     MOVE.L  y0,D1
    197. 

  197.     MOVE.L  x1,D2
    198. 

  198.     MOVE.L  y1,D3
    199. 

  199.     MOVE.L  flags,D4
    200. 

  200.     MOVEA.L bm2,A2
    201. 

  201.     MOVEA.L LayersBase,A6
    202. 

  202.     JSR -042(A6)
    203. 

  203.     MOVEA.L (A7)+,A6
    204. 

  204.     MOVE.L  D0,@RESULT
    205. 

  205.   END;
    206. 

  206. END;
    207. 

  207. 

  208. FUNCTION CreateUpfrontHookLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; hook : pHook; bm2 : pBitMap) : pLayer;
    209. 

  209. BEGIN
    210. 

  210.   ASM
    211. 

  211.     MOVE.L  A6,-(A7)
    212. 

  212.     MOVEA.L li,A0
    213. 

  213.     MOVEA.L bm,A1
    214. 

  214.     MOVE.L  x0,D0
    215. 

  215.     MOVE.L  y0,D1
    216. 

  216.     MOVE.L  x1,D2
    217. 

  217.     MOVE.L  y1,D3
    218. 

  218.     MOVE.L  flags,D4
    219. 

  219.     MOVEA.L hook,A3
    220. 

  220.     MOVEA.L bm2,A2
    221. 

  221.     MOVEA.L LayersBase,A6
    222. 

  222.     JSR -186(A6)
    223. 

  223.     MOVEA.L (A7)+,A6
    224. 

  224.     MOVE.L  D0,@RESULT
    225. 

  225.   END;
    226. 

  226. END;
    227. 

  227. 

  228. FUNCTION CreateUpfrontLayer(li : pLayer_Info; bm : pBitMap; x0 : LONGINT; y0 : LONGINT; x1 : LONGINT; y1 : LONGINT; flags : LONGINT; bm2 : pBitMap) : pLayer;
    229. 

  229. BEGIN
    230. 

  230.   ASM
    231. 

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

  232.     MOVEA.L li,A0
    233. 

  233.     MOVEA.L bm,A1
    234. 

  234.     MOVE.L  x0,D0
    235. 

  235.     MOVE.L  y0,D1
    236. 

  236.     MOVE.L  x1,D2
    237. 

  237.     MOVE.L  y1,D3
    238. 

  238.     MOVE.L  flags,D4
    239. 

  239.     MOVEA.L bm2,A2
    240. 

  240.     MOVEA.L LayersBase,A6
    241. 

  241.     JSR -036(A6)
    242. 

  242.     MOVEA.L (A7)+,A6
    243. 

  243.     MOVE.L  D0,@RESULT
    244. 

  244.   END;
    245. 

  245. END;
    246. 

  246. 

  247. FUNCTION DeleteLayer(dummy : LONGINT; layer : pLayer) : LONGINT;
    248. 

  248. BEGIN
    249. 

  249.   ASM
    250. 

  250.     MOVE.L  A6,-(A7)
    251. 

  251.     MOVEA.L dummy,A0
    252. 

  252.     MOVEA.L layer,A1
    253. 

  253.     MOVEA.L LayersBase,A6
    254. 

  254.     JSR -090(A6)
    255. 

  255.     MOVEA.L (A7)+,A6
    256. 

  256.     MOVE.L  D0,@RESULT
    257. 

  257.   END;
    258. 

  258. END;
    259. 

  259. 

  260. PROCEDURE DisposeLayerInfo(li : pLayer_Info);
    261. 

  261. BEGIN
    262. 

  262.   ASM
    263. 

  263.     MOVE.L  A6,-(A7)
    264. 

  264.     MOVEA.L li,A0
    265. 

  265.     MOVEA.L LayersBase,A6
    266. 

  266.     JSR -150(A6)
    267. 

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

  268.   END;
    269. 

  269. END;
    270. 

  270. 

  271. PROCEDURE DoHookClipRects(hook : pHook; rport : pRastPort;const rect : pRectangle);
    272. 

  272. BEGIN
    273. 

  273.   ASM
    274. 

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

  275.     MOVEA.L hook,A0
    276. 

  276.     MOVEA.L rport,A1
    277. 

  277.     MOVEA.L rect,A2
    278. 

  278.     MOVEA.L LayersBase,A6
    279. 

  279.     JSR -216(A6)
    280. 

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

  281.   END;
    282. 

  282. END;
    283. 

  283. 

  284. PROCEDURE EndUpdate(layer : pLayer; flag : ULONG);
    285. 

  285. BEGIN
    286. 

  286.   ASM
    287. 

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

  288.     MOVEA.L layer,A0
    289. 

  289.     MOVE.L  flag,D0
    290. 

  290.     MOVEA.L LayersBase,A6
    291. 

  291.     JSR -084(A6)
    292. 

  292.     MOVEA.L (A7)+,A6
    293. 

  293.   END;
    294. 

  294. END;
    295. 

  295. 

  296. FUNCTION FattenLayerInfo(li : pLayer_Info) : LONGINT;
    297. 

  297. BEGIN
    298. 

  298.   ASM
    299. 

  299.     MOVE.L  A6,-(A7)
    300. 

  300.     MOVEA.L li,A0
    301. 

  301.     MOVEA.L LayersBase,A6
    302. 

  302.     JSR -156(A6)
    303. 

  303.     MOVEA.L (A7)+,A6
    304. 

  304.     MOVE.L  D0,@RESULT
    305. 

  305.   END;
    306. 

  306. END;
    307. 

  307. 

  308. PROCEDURE InitLayers(li : pLayer_Info);
    309. 

  309. BEGIN
    310. 

  310.   ASM
    311. 

  311.     MOVE.L  A6,-(A7)
    312. 

  312.     MOVEA.L li,A0
    313. 

  313.     MOVEA.L LayersBase,A6
    314. 

  314.     JSR -030(A6)
    315. 

  315.     MOVEA.L (A7)+,A6
    316. 

  316.   END;
    317. 

  317. END;
    318. 

  318. 

  319. FUNCTION InstallClipRegion(layer : pLayer;const region : pRegion) : pRegion;
    320. 

  320. BEGIN
    321. 

  321.   ASM
    322. 

  322.     MOVE.L  A6,-(A7)
    323. 

  323.     MOVEA.L layer,A0
    324. 

  324.     MOVEA.L region,A1
    325. 

  325.     MOVEA.L LayersBase,A6
    326. 

  326.     JSR -174(A6)
    327. 

  327.     MOVEA.L (A7)+,A6
    328. 

  328.     MOVE.L  D0,@RESULT
    329. 

  329.   END;
    330. 

  330. END;
    331. 

  331. 

  332. FUNCTION InstallLayerHook(layer : pLayer; hook : pHook) : pHook;
    333. 

  333. BEGIN
    334. 

  334.   ASM
    335. 

  335.     MOVE.L  A6,-(A7)
    336. 

  336.     MOVEA.L layer,A0
    337. 

  337.     MOVEA.L hook,A1
    338. 

  338.     MOVEA.L LayersBase,A6
    339. 

  339.     JSR -198(A6)
    340. 

  340.     MOVEA.L (A7)+,A6
    341. 

  341.     MOVE.L  D0,@RESULT
    342. 

  342.   END;
    343. 

  343. END;
    344. 

  344. 

  345. FUNCTION InstallLayerInfoHook(li : pLayer_Info;const hook : pHook) : pHook;
    346. 

  346. BEGIN
    347. 

  347.   ASM
    348. 

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

  349.     MOVEA.L li,A0
    350. 

  350.     MOVEA.L hook,A1
    351. 

  351.     MOVEA.L LayersBase,A6
    352. 

  352.     JSR -204(A6)
    353. 

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

  354.     MOVE.L  D0,@RESULT
    355. 

  355.   END;
    356. 

  356. END;
    357. 

  357. 

  358. PROCEDURE LockLayer(dummy : LONGINT; layer : pLayer);
    359. 

  359. BEGIN
    360. 

  360.   ASM
    361. 

  361.     MOVE.L  A6,-(A7)
    362. 

  362.     MOVEA.L dummy,A0
    363. 

  363.     MOVEA.L layer,A1
    364. 

  364.     MOVEA.L LayersBase,A6
    365. 

  365.     JSR -096(A6)
    366. 

  366.     MOVEA.L (A7)+,A6
    367. 

  367.   END;
    368. 

  368. END;
    369. 

  369. 

  370. PROCEDURE LockLayerInfo(li : pLayer_Info);
    371. 

  371. BEGIN
    372. 

  372.   ASM
    373. 

  373.     MOVE.L  A6,-(A7)
    374. 

  374.     MOVEA.L li,A0
    375. 

  375.     MOVEA.L LayersBase,A6
    376. 

  376.     JSR -120(A6)
    377. 

  377.     MOVEA.L (A7)+,A6
    378. 

  378.   END;
    379. 

  379. END;
    380. 

  380. 

  381. PROCEDURE LockLayers(li : pLayer_Info);
    382. 

  382. BEGIN
    383. 

  383.   ASM
    384. 

  384.     MOVE.L  A6,-(A7)
    385. 

  385.     MOVEA.L li,A0
    386. 

  386.     MOVEA.L LayersBase,A6
    387. 

  387.     JSR -108(A6)
    388. 

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

  389.   END;
    390. 

  390. END;
    391. 

  391. 

  392. FUNCTION MoveLayer(dummy : LONGINT; layer : pLayer; dx : LONGINT; dy : LONGINT) : LONGINT;
    393. 

  393. BEGIN
    394. 

  394.   ASM
    395. 

  395.     MOVE.L  A6,-(A7)
    396. 

  396.     MOVEA.L dummy,A0
    397. 

  397.     MOVEA.L layer,A1
    398. 

  398.     MOVE.L  dx,D0
    399. 

  399.     MOVE.L  dy,D1
    400. 

  400.     MOVEA.L LayersBase,A6
    401. 

  401.     JSR -060(A6)
    402. 

  402.     MOVEA.L (A7)+,A6
    403. 

  403.     MOVE.L  D0,@RESULT
    404. 

  404.   END;
    405. 

  405. END;
    406. 

  406. 

  407. FUNCTION MoveLayerInFrontOf(layer_to_move : pLayer; other_layer : pLayer) : LONGINT;
    408. 

  408. BEGIN
    409. 

  409.   ASM
    410. 

  410.     MOVE.L  A6,-(A7)
    411. 

  411.     MOVEA.L layer_to_move,A0
    412. 

  412.     MOVEA.L other_layer,A1
    413. 

  413.     MOVEA.L LayersBase,A6
    414. 

  414.     JSR -168(A6)
    415. 

  415.     MOVEA.L (A7)+,A6
    416. 

  416.     MOVE.L  D0,@RESULT
    417. 

  417.   END;
    418. 

  418. END;
    419. 

  419. 

  420. FUNCTION MoveSizeLayer(layer : pLayer; dx : LONGINT; dy : LONGINT; dw : LONGINT; dh : LONGINT) : LONGINT;
    421. 

  421. BEGIN
    422. 

  422.   ASM
    423. 

  423.     MOVE.L  A6,-(A7)
    424. 

  424.     MOVEA.L layer,A0
    425. 

  425.     MOVE.L  dx,D0
    426. 

  426.     MOVE.L  dy,D1
    427. 

  427.     MOVE.L  dw,D2
    428. 

  428.     MOVE.L  dh,D3
    429. 

  429.     MOVEA.L LayersBase,A6
    430. 

  430.     JSR -180(A6)
    431. 

  431.     MOVEA.L (A7)+,A6
    432. 

  432.     MOVE.L  D0,@RESULT
    433. 

  433.   END;
    434. 

  434. END;
    435. 

  435. 

  436. FUNCTION NewLayerInfo : pLayer_Info;
    437. 

  437. BEGIN
    438. 

  438.   ASM
    439. 

  439.     MOVE.L  A6,-(A7)
    440. 

  440.     MOVEA.L LayersBase,A6
    441. 

  441.     JSR -144(A6)
    442. 

  442.     MOVEA.L (A7)+,A6
    443. 

  443.     MOVE.L  D0,@RESULT
    444. 

  444.   END;
    445. 

  445. END;
    446. 

  446. 

  447. PROCEDURE ScrollLayer(dummy : LONGINT; layer : pLayer; dx : LONGINT; dy : LONGINT);
    448. 

  448. BEGIN
    449. 

  449.   ASM
    450. 

  450.     MOVE.L  A6,-(A7)
    451. 

  451.     MOVEA.L dummy,A0
    452. 

  452.     MOVEA.L layer,A1
    453. 

  453.     MOVE.L  dx,D0
    454. 

  454.     MOVE.L  dy,D1
    455. 

  455.     MOVEA.L LayersBase,A6
    456. 

  456.     JSR -072(A6)
    457. 

  457.     MOVEA.L (A7)+,A6
    458. 

  458.   END;
    459. 

  459. END;
    460. 

  460. 

  461. FUNCTION SizeLayer(dummy : LONGINT; layer : pLayer; dx : LONGINT; dy : LONGINT) : LONGINT;
    462. 

  462. BEGIN
    463. 

  463.   ASM
    464. 

  464.     MOVE.L  A6,-(A7)
    465. 

  465.     MOVEA.L dummy,A0
    466. 

  466.     MOVEA.L layer,A1
    467. 

  467.     MOVE.L  dx,D0
    468. 

  468.     MOVE.L  dy,D1
    469. 

  469.     MOVEA.L LayersBase,A6
    470. 

  470.     JSR -066(A6)
    471. 

  471.     MOVEA.L (A7)+,A6
    472. 

  472.     MOVE.L  D0,@RESULT
    473. 

  473.   END;
    474. 

  474. END;
    475. 

  475. 

  476. PROCEDURE SortLayerCR(layer : pLayer; dx : LONGINT; dy : LONGINT);
    477. 

  477. BEGIN
    478. 

  478.   ASM
    479. 

  479.     MOVE.L  A6,-(A7)
    480. 

  480.     MOVEA.L layer,A0
    481. 

  481.     MOVE.L  dx,D0
    482. 

  482.     MOVE.L  dy,D1
    483. 

  483.     MOVEA.L LayersBase,A6
    484. 

  484.     JSR -210(A6)
    485. 

  485.     MOVEA.L (A7)+,A6
    486. 

  486.   END;
    487. 

  487. END;
    488. 

  488. 

  489. PROCEDURE SwapBitsRastPortClipRect(rp : pRastPort; cr : pClipRect);
    490. 

  490. BEGIN
    491. 

  491.   ASM
    492. 

  492.     MOVE.L  A6,-(A7)
    493. 

  493.     MOVEA.L rp,A0
    494. 

  494.     MOVEA.L cr,A1
    495. 

  495.     MOVEA.L LayersBase,A6
    496. 

  496.     JSR -126(A6)
    497. 

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

  498.   END;
    499. 

  499. END;
    500. 

  500. 

  501. PROCEDURE ThinLayerInfo(li : pLayer_Info);
    502. 

  502. BEGIN
    503. 

  503.   ASM
    504. 

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

  505.     MOVEA.L li,A0
    506. 

  506.     MOVEA.L LayersBase,A6
    507. 

  507.     JSR -162(A6)
    508. 

  508.     MOVEA.L (A7)+,A6
    509. 

  509.   END;
    510. 

  510. END;
    511. 

  511. 

  512. PROCEDURE UnlockLayer(layer : pLayer);
    513. 

  513. BEGIN
    514. 

  514.   ASM
    515. 

  515.     MOVE.L  A6,-(A7)
    516. 

  516.     MOVEA.L layer,A0
    517. 

  517.     MOVEA.L LayersBase,A6
    518. 

  518.     JSR -102(A6)
    519. 

  519.     MOVEA.L (A7)+,A6
    520. 

  520.   END;
    521. 

  521. END;
    522. 

  522. 

  523. PROCEDURE UnlockLayerInfo(li : pLayer_Info);
    524. 

  524. BEGIN
    525. 

  525.   ASM
    526. 

  526.     MOVE.L  A6,-(A7)
    527. 

  527.     MOVEA.L li,A0
    528. 

  528.     MOVEA.L LayersBase,A6
    529. 

  529.     JSR -138(A6)
    530. 

  530.     MOVEA.L (A7)+,A6
    531. 

  531.   END;
    532. 

  532. END;
    533. 

  533. 

  534. PROCEDURE UnlockLayers(li : pLayer_Info);
    535. 

  535. BEGIN
    536. 

  536.   ASM
    537. 

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

  538.     MOVEA.L li,A0
    539. 

  539.     MOVEA.L LayersBase,A6
    540. 

  540.     JSR -114(A6)
    541. 

  541.     MOVEA.L (A7)+,A6
    542. 

  542.   END;
    543. 

  543. END;
    544. 

  544. 

  545. FUNCTION UpfrontLayer(dummy : LONGINT; layer : pLayer) : LONGINT;
    546. 

  546. BEGIN
    547. 

  547.   ASM
    548. 

  548.     MOVE.L  A6,-(A7)
    549. 

  549.     MOVEA.L dummy,A0
    550. 

  550.     MOVEA.L layer,A1
    551. 

  551.     MOVEA.L LayersBase,A6
    552. 

  552.     JSR -048(A6)
    553. 

  553.     MOVEA.L (A7)+,A6
    554. 

  554.     MOVE.L  D0,@RESULT
    555. 

  555.   END;
    556. 

  556. END;
    557. 

  557. 

  558. FUNCTION WhichLayer(li : pLayer_Info; x : LONGINT; y : LONGINT) : pLayer;
    559. 

  559. BEGIN
    560. 

  560.   ASM
    561. 

  561.     MOVE.L  A6,-(A7)
    562. 

  562.     MOVEA.L li,A0
    563. 

  563.     MOVE.L  x,D0
    564. 

  564.     MOVE.L  y,D1
    565. 

  565.     MOVEA.L LayersBase,A6
    566. 

  566.     JSR -132(A6)
    567. 

  567.     MOVEA.L (A7)+,A6
    568. 

  568.     MOVE.L  D0,@RESULT
    569. 

  569.   END;
    570. 

  570. END;
    571. 

  571. 

  572. const
    573. 

  573.     { Change VERSION and LIBVERSION to proper values }
    574. 

  574. 

  575.     VERSION : string[2] = '0';
    576. 

  576.     LIBVERSION : longword = 0;
    577. 

  577. 

  578. {$ifdef use_init_openlib}
    579. 

  579.   {$Info Compiling initopening of layers.library}
    580. 

  580.   {$Info don't forget to use InitLAYERSLibrary in the beginning of your program}
    581. 

    582. 

  582. var
    583. 

  583.     layers_exit : Pointer;
    584. 

  584. 

  585. procedure CloselayersLibrary;
    586. 

  586. begin
    587. 

  587.     ExitProc := layers_exit;
    588. 

  588.     if LayersBase <> nil then begin
    589. 

  589.         CloseLibrary(LayersBase);
    590. 

  590.         LayersBase := nil;
    591. 

  591.     end;
    592. 

  592. end;
    593. 

  593. 

  594. procedure InitLAYERSLibrary;
    595. 

  595. begin
    596. 

  596.     LayersBase := nil;
    597. 

  597.     LayersBase := OpenLibrary(LAYERSNAME,LIBVERSION);
    598. 

  598.     if LayersBase <> nil then begin
    599. 

  599.         layers_exit := ExitProc;
    600. 

  600.         ExitProc := @CloselayersLibrary;
    601. 

  601.     end else begin
    602. 

  602.         MessageBox('FPC Pascal Error',
    603. 

  603.         'Can''t open layers.library version ' + VERSION + #10 +
    604. 

  604.         'Deallocating resources and closing down',
    605. 

  605.         'Oops');
    606. 

  606.         halt(20);
    607. 

  607.     end;
    608. 

  608. end;
    609. 

  609. 

  610. begin
    611. 

  611.     LAYERSIsCompiledHow := 2;
    612. 

  612. {$endif use_init_openlib}
    613. 

  613. 

  614. {$ifdef use_auto_openlib}
    615. 

  615.   {$Info Compiling autoopening of layers.library}
    616. 

  616. 

  617. var
    618. 

  618.     layers_exit : Pointer;
    619. 

  619. 

  620. procedure CloselayersLibrary;
    621. 

  621. begin
    622. 

  622.     ExitProc := layers_exit;
    623. 

  623.     if LayersBase <> nil then begin
    624. 

  624.         CloseLibrary(LayersBase);
    625. 

  625.         LayersBase := nil;
    626. 

  626.     end;
    627. 

  627. end;
    628. 

  628. 

  629. begin
    630. 

  630.     LayersBase := nil;
    631. 

  631.     LayersBase := OpenLibrary(LAYERSNAME,LIBVERSION);
    632. 

  632.     if LayersBase <> nil then begin
    633. 

  633.         layers_exit := ExitProc;
    634. 

  634.         ExitProc := @CloselayersLibrary;
    635. 

  635.         LAYERSIsCompiledHow := 1;
    636. 

  636.     end else begin
    637. 

  637.         MessageBox('FPC Pascal Error',
    638. 

  638.         'Can''t open layers.library version ' + VERSION + #10 +
    639. 

  639.         'Deallocating resources and closing down',
    640. 

  640.         'Oops');
    641. 

  641.         halt(20);
    642. 

  642.     end;
    643. 

  643. 

  644. {$endif use_auto_openlib}
    645. 

  645. 

  646. {$ifdef dont_use_openlib}
    647. 

  647. begin
    648. 

  648.     LAYERSIsCompiledHow := 3;
    649. 

  649.    {$Warning No autoopening of layers.library compiled}
    650. 

  650.    {$Warning Make sure you open layers.library yourself}
    651. 

  651. {$endif dont_use_openlib}
    652. 

  652. 

  653. 

  654. END. (* UNIT LAYERS *)
    655.