home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Misc / OB3.2D3.DMS / in.adf / Interfaces / Layers.mod < prev    next >
Encoding:
Text File  |  1993-05-23  |  7.1 KB  |  131 lines
  1. (*-------------------------------------------------------------------------*)
  2. (*                                                                         *)
  3. (*  Amiga Oberon Interface Module:                    Date: 02-Nov-92      *)
  4. (*                                                                         *)
  5. (*   © 1992 by Fridtjof Siebert                                            *)
  6. (*   updated for V39 by hartmut Goebel                                     *)
  7. (*                                                                         *)
  8. (*-------------------------------------------------------------------------*)
  9.  
  10. MODULE Layers;
  11.  
  12. IMPORT e * := Exec,
  13.        g * := Graphics,
  14.        u * := Utility;
  15.  
  16. TYPE
  17.   LONGBOOL * = e.LONGBOOL;
  18.  
  19. CONST
  20.   layersName * = "layers.library";
  21.   LTRUE * = e.LTRUE;
  22.   LFALSE * = e.LFALSE;
  23.  
  24. VAR
  25.   base * : e.LibraryPtr;
  26.  
  27. PROCEDURE InitLayers        *{base,- 30}(li{8}         : g.LayerInfoPtr);
  28. PROCEDURE CreateUpfrontLayer*{base,- 36}(li{8}         : g.LayerInfoPtr;
  29.                                          bm{9}         : g.BitMapPtr;
  30.                                          x0{0}         : LONGINT;
  31.                                          y0{1}         : LONGINT;
  32.                                          x1{2}         : LONGINT;
  33.                                          y1{3}         : LONGINT;
  34.                                          flags{4}      : SET;
  35.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  36. PROCEDURE CreateBehindLayer *{base,- 42}(li{8}         : g.LayerInfoPtr;
  37.                                          bm{9}         : g.BitMapPtr;
  38.                                          x0{0}         : LONGINT;
  39.                                          y0{1}         : LONGINT;
  40.                                          x1{2}         : LONGINT;
  41.                                          y1{3}         : LONGINT;
  42.                                          flags{4}      : SET;
  43.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  44. PROCEDURE UpfrontLayer      *{base,- 48}(layer{9}      : g.LayerPtr): BOOLEAN;
  45. PROCEDURE BehindLayer       *{base,- 54}(layer{9}      : g.LayerPtr): BOOLEAN;
  46. PROCEDURE MoveLayer         *{base,- 60}(layer{9}      : g.LayerPtr;
  47.                                          dx{0}         : LONGINT;
  48.                                          dy{1}         : LONGINT): BOOLEAN;
  49. PROCEDURE SizeLayer         *{base,- 66}(layer{9}      : g.LayerPtr;
  50.                                          dx{0}         : LONGINT;
  51.                                          dy{1}         : LONGINT): BOOLEAN;
  52. PROCEDURE ScrollLayer       *{base,- 72}(layer{9}      : g.LayerPtr;
  53.                                          dx{0}         : LONGINT;
  54.                                          dy{1}         : LONGINT);
  55. PROCEDURE BeginUpdate       *{base,- 78}(l{8}          : g.LayerPtr): BOOLEAN;
  56. PROCEDURE EndUpdate         *{base,- 84}(layer{8}      : g.LayerPtr;
  57.                                          flag{0}       : LONGBOOL);
  58. PROCEDURE DeleteLayer       *{base,- 90}(layer{9}      : g.LayerPtr): BOOLEAN;
  59. PROCEDURE LockLayer         *{base,- 96}(layer{9}      : g.LayerPtr);
  60. PROCEDURE UnlockLayer       *{base,-102}(layer{8}      : g.LayerPtr);
  61. PROCEDURE LockLayers        *{base,-108}(li{8}         : g.LayerInfoPtr);
  62. PROCEDURE UnlockLayers      *{base,-114}(li{8}         : g.LayerInfoPtr);
  63. PROCEDURE LockLayerInfo     *{base,-120}(li{8}         : g.LayerInfoPtr);
  64. PROCEDURE SwapBitsRastPortClipRect*{base,-126}(rp{8}   : g.RastPortPtr;
  65.                                          VAR cr{9}     : g.ClipRect);
  66. PROCEDURE WhichLayer        *{base,-132}(li{8}         : g.LayerInfoPtr;
  67.                                          x{0}          : LONGINT;
  68.                                          y{1}          : LONGINT): g.LayerPtr;
  69. PROCEDURE UnlockLayerInfo   *{base,-138}(VAR li{8}     : g.LayerInfo);
  70. PROCEDURE NewLayerInfo      *{base,-144}(): g.LayerInfoPtr;
  71. PROCEDURE DisposeLayerInfo  *{base,-150}(li{8}         : g.LayerInfoPtr);
  72. PROCEDURE FattenLayerInfo   *{base,-156}(li{8}         : g.LayerInfoPtr);
  73. PROCEDURE ThinLayerInfo     *{base,-162}(li{8}         : g.LayerInfoPtr);
  74. PROCEDURE MoveLayerInFrontOf*{base,-168}(layertomove{8}: g.LayerPtr;
  75.                                          otherlayer{9} : g.LayerPtr): BOOLEAN;
  76. PROCEDURE InstallClipRegion *{base,-174}(layer{8}      : g.LayerPtr;
  77.                                          region{9}     : g.RegionPtr): g.RegionPtr;
  78. (* ---   functions in V36 or higher  (distributed as Release 2.0)   --- *)
  79. (* --- REMEMBER: You are to check the version BEFORE you use this ! --- *)
  80. PROCEDURE MoveSizeLayer     *{base,-180}(layer{8}      : g.LayerPtr;
  81.                                          dx{0}         : LONGINT;
  82.                                          dy{1}         : LONGINT;
  83.                                          dw{2}         : LONGINT;
  84.                                          dh{3}         : LONGINT): BOOLEAN;
  85. PROCEDURE CreateUpfrontHookLayer*{base,-186}(li{8}     : g.LayerInfoPtr;
  86.                                          bm{9}         : g.BitMapPtr;
  87.                                          x0{0}         : LONGINT;
  88.                                          y0{1}         : LONGINT;
  89.                                          x1{2}         : LONGINT;
  90.                                          y1{3}         : LONGINT;
  91.                                          flags{4}      : SET;
  92.                                          hook{11}      : u.HookPtr;
  93.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  94. PROCEDURE CreateBehindHookLayer*{base,-192}(li{8}      : g.LayerInfoPtr;
  95.                                          bm{9}         : g.BitMapPtr;
  96.                                          x0{0}         : LONGINT;
  97.                                          y0{1}         : LONGINT;
  98.                                          x1{2}         : LONGINT;
  99.                                          y1{3}         : LONGINT;
  100.                                          flags{4}      : SET;
  101.                                          hook{11}      : u.HookPtr;
  102.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  103. PROCEDURE InstallLayerHook  *{base,-198}(layer{8}      : g.LayerPtr;
  104.                                          hook{9}       : u.HookPtr): u.HookPtr;
  105.  
  106. (*--- functions in V39 or higher (beta release for developers only) ---*)
  107.  
  108. PROCEDURE InstallLayerInfoHook*{base,-0CCH}(li{8}      : g.LayerInfoPtr;
  109.                                             hook{9}    : u.HookPtr): u.HookPtr;
  110. PROCEDURE SortLayerCR       *{base,-0D2H}(layer{8}     : g.LayerPtr;
  111.                                           dx{0}        : LONGINT;
  112.                                           dy{1}        : LONGINT);
  113. PROCEDURE DoHookClipRects   *{base,-0D8H}(hook{8}      : u.HookPtr;
  114.                                           rport{9}     : g.RastPortPtr;
  115.                                           rect{10}     : g.Rectangle);
  116.  
  117.  
  118. (* $OvflChk- $RangeChk- $StackChk- $NilChk- $ReturnChk- $CaseChk- *)
  119.  
  120. BEGIN
  121.  
  122.  base := e.OpenLibrary(layersName,33);
  123.  IF base=NIL THEN HALT(0) END;
  124.  
  125. CLOSE
  126.  
  127.  IF base#NIL THEN e.CloseLibrary(base) END;
  128.  
  129. END Layers.
  130.  
  131.