home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / td187src.lzh / MAGICAES.I < prev    next >
Text File  |  1991-06-08  |  24KB  |  958 lines
  1. (*######################################################################
  2.                                                                         
  3.   MAGIC         Modula's  All purpose  GEM  Interface  Cadre
  4.                                                         
  5. ########################################################################
  6.  
  7.   AES   Application Environment Services        Interface for Modula-2
  8.  
  9. ########################################################################
  10.   V2.01 24.10.90  Peter Hellinger   Systemaufrufe nach MagicSys ver-
  11.                                     lagert, dadurch ist MagicAES
  12.                                     fast unabhängig vom Compiler.
  13.   V2.00 16.10.90  Peter Hellinger   Anpassung an neues MagicSys
  14.   V1.04 05.08.90  Peter Hellinger
  15.   V1.01 18.06.90  Peter Hellinger   Xgraf-Funktionen implementiert
  16.   V1.00 (C) by    Peter Hellinger
  17. ######################################################################*)
  18.  
  19. IMPLEMENTATION MODULE MagicAES;
  20.  
  21. (*------------------------------*)
  22. (*       COMPILERSWITCHES       *)
  23. (*------------------------------*)
  24. (* TDI-Version:   DEAKTIVIERT   *)
  25. (*------------------------------*)
  26. (* V-  Overflow-Checks          *)
  27. (* R-  Range-Checks             *)
  28. (* S-  Stack-Check              *)
  29. (* N-  NIL-Checks               *)
  30. (* T-  TDI-Compiler vor 3.01    *)
  31. (* Q+  Branch statt Jumps       *)
  32. (*                              *)
  33. (*------------------------------*)
  34. (* MM2-Version:     AKTIVIERT   *)
  35. (*------------------------------*)
  36. (*$R-   Range-Checks            *)
  37. (*$S-   Stack-Check             *)
  38. (*                              *)
  39. (*------------------------------*)
  40.  
  41.  
  42. FROM SYSTEM     IMPORT  ADDRESS, ADR;
  43. FROM MagicSys   IMPORT  Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7,
  44.                         Bit8, Bit9, Bit10, Bit11, Bit12, Bit13, Bit14, Bit15,
  45.                         LOC, Byte, ByteSet, sWORD, sINTEGER, sCARDINAL, sBITSET,
  46.                         lWORD, lINTEGER, lCARDINAL, lBITSET,
  47.                         CastToChar, CastToByte, CastToByteset, CastToInt,
  48.                         CastToCard, CastToBitset, CastToWord, CastToLInt,
  49.                         CastToLCard, CastToLBitset, CastToLWord, CastToAddr,
  50.                         CallGEM;
  51.  
  52.  
  53. VAR array:  POINTER TO ARRAY [0..255] OF sINTEGER;
  54.     aespb:  ADDRESS; (* Adresse des AES-Parameterblocks *)
  55.  
  56.  
  57. (*#######################################################################*)
  58.  
  59.  
  60. PROCEDURE AESCall (op, c1, c2, c3, c4: sINTEGER): sINTEGER;
  61. BEGIN
  62.  WITH AESControl DO
  63.   opcode:= op;
  64.   sizeIntIn:= c1;
  65.   sizeIntOut:= c2;
  66.   sizeAddrIn:= c3;
  67.   sizeAddrOut:= c4;
  68.  END;
  69.  CallGEM (200, aespb);
  70.  CallResult:= AESIntOut[0];
  71.  RETURN CallResult;
  72. END AESCall;
  73.  
  74.  
  75. PROCEDURE ApplInit(): sINTEGER;
  76. BEGIN
  77.  RETURN AESCall(10, 0, 1, 0, 0);
  78. END ApplInit;
  79.  
  80.  
  81. PROCEDURE ApplRead (id, len: sINTEGER; VAR pipe: ARRAY OF LOC);
  82. BEGIN
  83.  AESIntIn[ 0]:=  id;
  84.  AESIntIn[ 1]:=  len;
  85.  AESAddrIn[ 0]:= ADR(pipe);
  86.  CallResult:= AESCall(11, 2, 1, 1, 0);
  87. END ApplRead;
  88.  
  89.  
  90. PROCEDURE ApplWrite (id, len: sINTEGER; VAR pipe: ARRAY OF LOC);
  91. BEGIN
  92.  AESIntIn[ 0]:=  id;
  93.  AESIntIn[ 1]:=  len;
  94.  AESAddrIn[ 0]:= ADR(pipe);
  95.  CallResult:= AESCall(12, 2, 1, 1, 0);
  96. END ApplWrite;
  97.  
  98.  
  99. PROCEDURE ApplFind (name: ARRAY OF CHAR): sINTEGER;
  100. BEGIN
  101.  AESAddrIn[ 0]:= ADR(name);
  102.  RETURN AESCall(13, 0, 1, 1, 0);
  103. END ApplFind;
  104.  
  105.  
  106. PROCEDURE ApplTplay (num, speed: sINTEGER; VAR buffer: ARRAY OF LOC);
  107. BEGIN
  108.  AESIntIn[ 0]:=  num;
  109.  AESIntIn[ 1]:=  speed;
  110.  AESAddrIn[ 0]:= ADR(buffer);
  111.  CallResult:= AESCall(14, 2, 1, 1, 0);
  112. END ApplTplay;
  113.  
  114.  
  115. PROCEDURE ApplTrecord (count: sINTEGER; VAR buffer: ARRAY OF LOC): sINTEGER;
  116. BEGIN
  117.  AESIntIn[ 0]:=  count;
  118.  AESAddrIn[ 0]:= ADR(buffer);
  119.  RETURN AESCall(15, 1, 1, 1, 0);
  120. END ApplTrecord;
  121.  
  122.  
  123. PROCEDURE ApplBvset (disk, hard: sBITSET);
  124. BEGIN
  125.  AESIntIn[ 0]:= CastToInt (disk);
  126.  AESIntIn[ 1]:= CastToInt (hard);
  127.  CallResult:= AESCall(16, 2, 1, 1, 0);
  128. END ApplBvset;
  129.  
  130.  
  131. PROCEDURE ApplYield;
  132. BEGIN
  133.  CallResult:= AESCall(17, 0, 1, 0, 0);
  134. END ApplYield;
  135.  
  136.  
  137. PROCEDURE ApplExit;
  138. BEGIN
  139.  CallResult:= AESCall(19, 0, 1, 0, 0);
  140. END ApplExit;
  141.  
  142.  
  143. PROCEDURE EvntKeybd (VAR key, scan: sINTEGER;  VAR chr: CHAR);
  144. VAR split: RECORD
  145.             CASE: BOOLEAN OF
  146.              TRUE: wert: sINTEGER;|
  147.              FALSE: hi: CHAR;
  148.                     lo: CHAR;|
  149.             END;
  150.            END;
  151. BEGIN
  152.  split.wert:= AESCall(20, 0, 1, 0, 0); (* Auf Keyboard-Event warten *)
  153.  key:= split.wert;
  154.  scan:= ORD (split.hi);
  155.  chr:= split.lo;
  156. END EvntKeybd;
  157.  
  158.  
  159. PROCEDURE EvntMulti (which: sBITSET;  maxclicks: sINTEGER;  mask, state: sBITSET;
  160.                      m1mode: sINTEGER;  m1rect: ARRAY OF LOC;
  161.                      m2mode: sINTEGER;  m2rect: ARRAY OF LOC;
  162.                      VAR msgBuff: ARRAY OF LOC;
  163.                      loTimer, hiTimer: sINTEGER;
  164.                      VAR x, y: sINTEGER;
  165.                      VAR button: sBITSET;
  166.                      VAR taste: sINTEGER;
  167.                      VAR kbshift: sBITSET;
  168.                      VAR scan: sINTEGER;
  169.                      VAR ascii: CHAR;
  170.                      VAR clicks: sINTEGER): sBITSET;
  171. VAR split: RECORD
  172.             CASE: BOOLEAN OF
  173.              TRUE: wert: sINTEGER;|
  174.              FALSE: hi: CHAR;
  175.                     lo: CHAR;|
  176.             END;
  177.            END;
  178. VAR event: sBITSET;
  179. BEGIN (* multi *)
  180.  (* Array's laden *)
  181.  AESIntIn[ 0]:= CastToInt (which);
  182.  AESIntIn[ 1]:= maxclicks;
  183.  AESIntIn[ 2]:= CastToInt (mask);
  184.  AESIntIn[ 3]:= CastToInt (state);
  185.  AESIntIn[ 4]:= m1mode;
  186.  array:= ADR (m1rect);
  187.  AESIntIn[ 5]:= array^[0];
  188.  AESIntIn[ 6]:= array^[1];
  189.  AESIntIn[ 7]:= array^[2];
  190.  AESIntIn[ 8]:= array^[3];
  191.  AESIntIn[ 9]:= m2mode;
  192.  array:= ADR (m2rect);
  193.  AESIntIn[10]:= array^[0];
  194.  AESIntIn[11]:= array^[1];
  195.  AESIntIn[12]:= array^[2];
  196.  AESIntIn[13]:= array^[3];
  197.  AESIntIn[14]:= loTimer;
  198.  AESIntIn[15]:= hiTimer;
  199.  AESAddrIn[0]:= ADR(msgBuff);
  200.  
  201.  CallResult:= AESCall(25, 16, 7, 1, 0);
  202.  event:= CastToBitset (CallResult);
  203.  
  204.  x:= AESIntOut[1];
  205.  y:= AESIntOut[2];
  206.  button:= CastToBitset (AESIntOut[3]);
  207.  kbshift:= CastToBitset (AESIntOut[4]);
  208.  split.wert:= AESIntOut[5];
  209.  taste:= split.wert;
  210.  scan:= ORD (split.hi);
  211.  ascii:= split.lo;
  212.  clicks:= AESIntOut[6];
  213.  
  214.  RETURN event;
  215. END EvntMulti;
  216.  
  217.  
  218. PROCEDURE EvntPmulti (): sBITSET;
  219. BEGIN
  220.  CallResult:= AESCall(25, 16, 7, 1, 0);
  221.  RETURN CastToBitset (CallResult);
  222. END EvntPmulti;
  223.  
  224.  
  225. PROCEDURE EvntButton (maxclicks: sINTEGER; mask, state: sBITSET;
  226.                       VAR x, y: sINTEGER;  VAR button, kbshift: sBITSET): sINTEGER;
  227. VAR clicks: sINTEGER;
  228. BEGIN
  229.  AESIntIn[ 0]:= maxclicks;
  230.  AESIntIn[ 1]:= CastToInt (mask);
  231.  AESIntIn[ 1]:= CastToInt (state);
  232.  clicks:= AESCall(21, 3, 5, 0, 0);
  233.  x:= AESIntOut[1];
  234.  y:= AESIntOut[2];
  235.  button:= CastToBitset (AESIntOut[3]);
  236.  kbshift:= CastToBitset (AESIntOut[4]);
  237.  RETURN clicks;
  238. END EvntButton;
  239.  
  240.  
  241. PROCEDURE EvntMouse  (mode: sINTEGER;  VAR m1rect: ARRAY OF LOC;
  242.                       VAR x, y: sINTEGER;  VAR button, kbshift: sBITSET);
  243. BEGIN
  244.  AESIntIn[ 0]:= mode;
  245.  array:= ADR (m1rect);
  246.  AESIntIn[ 1]:= array^[0];
  247.  AESIntIn[ 2]:= array^[1];
  248.  AESIntIn[ 3]:= array^[2];
  249.  AESIntIn[ 4]:= array^[3];
  250.  CallResult:= AESCall(22, 5, 5, 0, 0);
  251.  x:= AESIntOut[1];
  252.  y:= AESIntOut[2];
  253.  button:=  CastToBitset (AESIntOut[3]);
  254.  kbshift:= CastToBitset (AESIntOut[4]);
  255. END EvntMouse;
  256.  
  257.  
  258. PROCEDURE EvntMesag (VAR buffer: ARRAY OF LOC);
  259. BEGIN
  260.  AESAddrIn[0]:= ADR(buffer);
  261.  CallResult:= AESCall(23, 0, 1, 1, 0);
  262. END EvntMesag;
  263.  
  264.  
  265. PROCEDURE EvntTimer (count: LONGCARD);
  266. VAR trick: RECORD
  267.             CASE : BOOLEAN OF
  268.              TRUE: long: lCARDINAL;|
  269.              FALSE: hi, lo: sINTEGER;|
  270.             END;
  271.            END;
  272. BEGIN
  273.  trick.long:= count;
  274.  AESIntIn[ 0]:= trick.lo;
  275.  AESIntIn[ 1]:= trick.hi;
  276.  CallResult:= AESCall(24, 2, 1, 0, 0);
  277. END EvntTimer;
  278.  
  279.  
  280. PROCEDURE EvntDclicks (new: sINTEGER; set: BOOLEAN): sINTEGER;
  281. BEGIN
  282.  AESIntIn[ 0]:= new;
  283.  IF set THEN  AESIntIn[ 1]:= 1;  ELSE  AESIntIn[ 1]:= 0;  END;
  284.  RETURN AESCall(26, 2, 1, 0, 0);
  285. END EvntDclicks;
  286.  
  287.  
  288. (*######################################################################*)
  289.  
  290.  
  291. PROCEDURE FormDo (tree: ADDRESS; start: sINTEGER): sINTEGER;
  292. BEGIN
  293.  AESIntIn[ 0]:= start;
  294.  AESAddrIn[0]:= tree;
  295.  RETURN AESCall(50, 1, 1, 1, 0);
  296. END FormDo;
  297.  
  298.  
  299. PROCEDURE FormDial (flag: sINTEGER; small, big: ARRAY OF LOC);
  300. BEGIN
  301.  AESIntIn[ 0]:= flag;
  302.  array:= ADR(small);
  303.  AESIntIn[ 1]:= array^[0];
  304.  AESIntIn[ 2]:= array^[1];
  305.  AESIntIn[ 3]:= array^[2];
  306.  AESIntIn[ 4]:= array^[3];
  307.  array:= ADR(big);
  308.  AESIntIn[ 5]:= array^[0];
  309.  AESIntIn[ 6]:= array^[1];
  310.  AESIntIn[ 7]:= array^[2];
  311.  AESIntIn[ 8]:= array^[3];
  312.  CallResult:= AESCall(51, 9, 1, 1, 0);
  313. END FormDial;
  314.  
  315.  
  316. PROCEDURE FormAlert  (button: sINTEGER; string: ARRAY OF CHAR): sINTEGER;
  317. BEGIN
  318.  AESIntIn[ 0]:= button;
  319.  AESAddrIn[0]:= ADR(string);
  320.  RETURN AESCall(52, 1, 1, 1, 0);
  321. END FormAlert;
  322.  
  323.  
  324. PROCEDURE FormError  (errNum: sINTEGER);
  325. BEGIN
  326.  AESIntIn[ 0]:= errNum;
  327.  CallResult:= AESCall(53, 1, 1, 0, 0);
  328. END FormError;
  329.  
  330.  
  331. PROCEDURE FormCenter (tree: ADDRESS; VAR rect: ARRAY OF LOC);
  332. BEGIN
  333.  AESAddrIn[0]:= tree;
  334.  CallResult:= AESCall(54, 0, 5, 1, 0);
  335.  array:= ADR(rect);
  336.  array^[0]:= AESIntOut[1];
  337.  array^[1]:= AESIntOut[2];
  338.  array^[2]:= AESIntOut[3];
  339.  array^[3]:= AESIntOut[4];
  340. END FormCenter;
  341.  
  342.  
  343. PROCEDURE FormKeybd (tree: ADDRESS;  object, chIn: sINTEGER;
  344.                      VAR next, chOut: sINTEGER): sINTEGER;
  345. BEGIN
  346.  AESIntIn[ 0]:= object;
  347.  AESIntIn[ 1]:= chIn;
  348.  AESIntIn[ 2]:= 0;
  349.  AESAddrIn[0]:= tree;
  350.  CallResult:= AESCall(55, 3, 3, 1, 0);
  351.  next:= AESIntOut[1];
  352.  chOut:= AESIntOut[2];
  353.  RETURN CallResult;  
  354. END FormKeybd;
  355.  
  356.  
  357. PROCEDURE FormButton (tree: ADDRESS; obj, cl: sINTEGER; VAR next: sINTEGER): sINTEGER;
  358. BEGIN
  359.  AESIntIn[ 0]:= obj;
  360.  AESIntIn[ 1]:= cl;
  361.  AESAddrIn[0]:= tree;
  362.  CallResult:= AESCall(56, 2, 2, 1, 0);
  363.  next:= AESIntOut[1];
  364.  RETURN CallResult;
  365. END FormButton;
  366.  
  367.  
  368. (*#######################################################################*)
  369.  
  370. PROCEDURE FselInput (VAR pfad, name: ARRAY OF CHAR): BOOLEAN;
  371. BEGIN
  372.  AESAddrIn[0]:= ADR(pfad);
  373.  AESAddrIn[1]:= ADR(name);
  374.  CallResult:= AESCall(90, 0, 2, 2, 0);
  375.  RETURN AESIntOut[1] = 1;
  376. END FselInput;
  377.  
  378.  
  379. PROCEDURE FselExinput (VAR info, pfad, name: ARRAY OF CHAR): BOOLEAN;
  380. BEGIN
  381.  AESAddrIn[0]:= ADR(pfad);
  382.  AESAddrIn[1]:= ADR(name);
  383.  AESAddrIn[2]:= ADR(info);
  384.  CallResult:= AESCall(91, 0, 2, 3, 0);
  385.  RETURN AESIntOut[1] = 1;
  386. END FselExinput;
  387.  
  388.  
  389. (*#######################################################################*)
  390.  
  391. PROCEDURE GrafRubberbox (x, y, mw, mh: sINTEGER; VAR lw, lh: sINTEGER);
  392. BEGIN
  393.  AESIntIn[ 0]:= x;
  394.  AESIntIn[ 1]:= y;
  395.  AESIntIn[ 2]:= mw;
  396.  AESIntIn[ 3]:= mh;
  397.  CallResult:= AESCall(70, 4, 3, 0, 0);
  398.  lw:= AESIntOut[1];
  399.  lh:= AESIntOut[2];
  400. END GrafRubberbox;
  401.  
  402.  
  403. PROCEDURE GrafDragbox (moving, boundary: ARRAY OF LOC; VAR x, y: sINTEGER);
  404. BEGIN
  405.  array:= ADR(moving);
  406.  AESIntIn[ 0]:= array^[2];
  407.  AESIntIn[ 1]:= array^[3];
  408.  AESIntIn[ 2]:= array^[0];
  409.  AESIntIn[ 3]:= array^[1];
  410.  array:= ADR(boundary);
  411.  AESIntIn[ 4]:= array^[0];
  412.  AESIntIn[ 5]:= array^[1];
  413.  AESIntIn[ 6]:= array^[2];
  414.  AESIntIn[ 7]:= array^[3];
  415.  CallResult:= AESCall(71, 8, 3, 0, 0);
  416.  x:= AESIntOut[1];
  417.  y:= AESIntOut[2];
  418. END GrafDragbox;
  419.  
  420.  
  421. PROCEDURE GrafMovebox (rect: ARRAY OF LOC; dx, dy: sINTEGER);
  422. BEGIN
  423.  array:= ADR(rect);
  424.  AESIntIn[ 0]:= array^[0];
  425.  AESIntIn[ 1]:= array^[1];
  426.  AESIntIn[ 2]:= array^[2];
  427.  AESIntIn[ 3]:= array^[3];
  428.  AESIntIn[ 4]:= dx;
  429.  AESIntIn[ 5]:= dy;
  430.  CallResult:= AESCall(72, 6, 1, 0, 0);
  431. END GrafMovebox;
  432.  
  433.  
  434. PROCEDURE GrafGrowbox (source, dest: ARRAY OF LOC);
  435. BEGIN
  436.  array:= ADR(source);
  437.  AESIntIn[ 0]:= array^[0];
  438.  AESIntIn[ 1]:= array^[1];
  439.  AESIntIn[ 2]:= array^[2];
  440.  AESIntIn[ 3]:= array^[3];
  441.  array:= ADR(dest);
  442.  AESIntIn[ 4]:= array^[0];
  443.  AESIntIn[ 5]:= array^[1];
  444.  AESIntIn[ 6]:= array^[2];
  445.  AESIntIn[ 7]:= array^[3];
  446.  CallResult:= AESCall(73, 8, 1, 0, 0);
  447. END GrafGrowbox;
  448.  
  449.  
  450. PROCEDURE GrafShrinkbox (source, dest: ARRAY OF LOC);
  451. BEGIN
  452.  array:= ADR(source);
  453.  AESIntIn[ 0]:= array^[0];
  454.  AESIntIn[ 1]:= array^[1];
  455.  AESIntIn[ 2]:= array^[2];
  456.  AESIntIn[ 3]:= array^[3];
  457.  array:= ADR(dest);
  458.  AESIntIn[ 4]:= array^[0];
  459.  AESIntIn[ 5]:= array^[1];
  460.  AESIntIn[ 6]:= array^[2];
  461.  AESIntIn[ 7]:= array^[3];
  462.  CallResult:= AESCall(74, 8, 1, 0, 0);
  463. END GrafShrinkbox;
  464.  
  465.  
  466. PROCEDURE GrafWatchbox (tree: ADDRESS; item: sINTEGER; in, out: sBITSET): sINTEGER;
  467. BEGIN
  468.  AESIntIn[1]:= item;
  469.  AESIntIn[2]:= CastToInt (in);
  470.  AESIntIn[3]:= CastToInt (out);
  471.  AESAddrIn[0]:= tree;
  472.  RETURN AESCall(75, 4, 1, 0, 0);
  473. END GrafWatchbox;
  474.  
  475.  
  476. PROCEDURE GrafSlidebox (tree: ADDRESS; parent, object, dir: sINTEGER): sINTEGER;
  477. BEGIN
  478.  AESIntIn[ 0]:= parent;
  479.  AESIntIn[ 1]:= object;
  480.  AESIntIn[ 2]:= dir;
  481.  AESAddrIn[ 0]:= tree;
  482.  RETURN AESCall(76, 3, 1, 0, 0);
  483. END GrafSlidebox;
  484.  
  485.  
  486. PROCEDURE GrafHandle (VAR handle, cw, ch, bw, bh: sINTEGER);
  487. BEGIN
  488.  CallResult:= AESCall(77, 0, 5, 0, 0);
  489.  handle:= AESIntOut[0];
  490.  cw:= AESIntOut[1];
  491.  ch:= AESIntOut[2];
  492.  bw:= AESIntOut[3];
  493.  bh:= AESIntOut[4];
  494. END GrafHandle;
  495.  
  496.  
  497. PROCEDURE GrafMouse (form: sINTEGER; user: ADDRESS);
  498. BEGIN
  499.  AESIntIn[0]:= form;
  500.  AESAddrIn[ 0]:= user;
  501.  CallResult:= AESCall(78, 1, 1, 0, 0);
  502. END GrafMouse;
  503.  
  504.  
  505. PROCEDURE GrafMkstate (VAR x, y: sINTEGER; VAR button, key: sBITSET);
  506. BEGIN
  507.  CallResult:= AESCall(79, 0, 5, 0, 0);
  508.  x:= AESIntOut[1];
  509.  y:= AESIntOut[2];
  510.  button:= CastToBitset (AESIntOut[3]);
  511.  key:= CastToBitset (AESIntOut[4]);
  512. END GrafMkstate;
  513.  
  514.  
  515. (*#######################################################################*)
  516.  
  517. PROCEDURE MenuBar (tree: ADDRESS; action: sINTEGER);
  518. BEGIN
  519.  AESIntIn[ 0]:= action;
  520.  AESAddrIn[0]:= tree;
  521.  CallResult:= AESCall(30, 1, 1, 1, 0);
  522. END MenuBar;
  523.  
  524.  
  525. PROCEDURE MenuIcheck (tree: ADDRESS; item: sINTEGER; action: sINTEGER);
  526. BEGIN
  527.  AESIntIn[ 0]:= item;
  528.  AESIntIn[ 1]:= action;
  529.  AESAddrIn[0]:= tree;
  530.  CallResult:= AESCall(31, 2, 1, 1, 0);
  531. END MenuIcheck;
  532.  
  533.  
  534. PROCEDURE MenuIenable (tree: ADDRESS; item: sINTEGER; action: sINTEGER);
  535. BEGIN
  536.  AESIntIn[ 0]:= item;
  537.  AESIntIn[ 1]:= action;
  538.  AESAddrIn[0]:= tree;
  539.  CallResult:= AESCall(32, 2, 1, 1, 0);
  540. END MenuIenable;
  541.  
  542.  
  543. PROCEDURE MenuTnormal (tree: ADDRESS; item: sINTEGER; action: sINTEGER);
  544. BEGIN
  545.  AESIntIn[ 0]:= item;
  546.  AESIntIn[ 1]:= action;
  547.  AESAddrIn[0]:= tree;
  548.  CallResult:= AESCall(33, 2, 1, 1, 0);
  549. END MenuTnormal;
  550.  
  551.  
  552. PROCEDURE MenuText (tree: ADDRESS; item: sINTEGER; str: ARRAY OF CHAR);
  553. BEGIN
  554.  AESIntIn[ 0]:= item;
  555.  AESAddrIn[0]:= tree;
  556.  AESAddrIn[1]:= ADR(str);
  557.  CallResult:= AESCall(34, 1, 1, 2, 0);
  558. END MenuText;
  559.  
  560.  
  561. PROCEDURE MenuRegister (apid: sINTEGER; str: ARRAY OF CHAR);
  562. BEGIN
  563.  AESIntIn[ 0]:= apid;
  564.  AESAddrIn[0]:= ADR(str);
  565.  CallResult:= AESCall(35, 1, 1, 1, 0);
  566. END MenuRegister;
  567.  
  568.  
  569. PROCEDURE MenuUnregister (apid: sINTEGER);
  570. BEGIN
  571.  AESIntIn[ 0]:= apid;
  572.  CallResult:= AESCall(36, 1, 1, 1, 0);
  573. END MenuUnregister;
  574.  
  575.  
  576. (*#######################################################################*)
  577.  
  578. PROCEDURE RsrcLoad (name: ARRAY OF CHAR): BOOLEAN;
  579. BEGIN
  580.  AESAddrIn[ 0]:= ADR(name);
  581.  CallResult:= AESCall(110, 0, 1, 1, 0);
  582.  RETURN CallResult # 0;
  583. END RsrcLoad;
  584.  
  585.  
  586. PROCEDURE RsrcFree;
  587. BEGIN
  588.  CallResult:= AESCall(111, 0, 1, 0, 0);
  589. END RsrcFree;
  590.  
  591.  
  592. PROCEDURE RsrcGaddr (type, item: sINTEGER): ADDRESS;
  593. BEGIN
  594.  AESIntIn[ 0]:= type;
  595.  AESIntIn[ 1]:= item;
  596.  CallResult:= AESCall(112, 2, 1, 0, 1);
  597.  RETURN  AESAddrOut[0];
  598. END RsrcGaddr;
  599.  
  600.  
  601. PROCEDURE RsrcSaddr (type, item: sINTEGER; adr: ADDRESS);
  602. BEGIN
  603.  AESIntIn[ 0]:= type;
  604.  AESIntIn[ 1]:= item;
  605.  AESAddrIn[0]:= adr;
  606.  CallResult:= AESCall(113, 2, 1, 1, 0);
  607. END RsrcSaddr;
  608.  
  609.  
  610. PROCEDURE RsrcObfix (tree: ADDRESS; object: sINTEGER);
  611. BEGIN
  612.  AESIntIn[ 0]:= object;
  613.  AESAddrIn[0]:= tree;
  614.  CallResult:= AESCall(114, 1, 1, 1, 0);
  615. END RsrcObfix;
  616.  
  617.  
  618. (*#######################################################################*)
  619.  
  620. PROCEDURE ScrpRead (VAR pfad: ARRAY OF CHAR): sBITSET;
  621. BEGIN
  622.  AESAddrIn[0]:= ADR(pfad);
  623.  CallResult:= AESCall(80, 0, 1, 1, 0);
  624.  RETURN CastToBitset (CallResult);
  625. END ScrpRead;
  626.  
  627.  
  628. PROCEDURE ScrpWrite (pfad: ARRAY OF CHAR);
  629. BEGIN
  630.  AESAddrIn[0]:= ADR(pfad);
  631.  CallResult:= AESCall(81, 0, 1, 1, 0);
  632. END ScrpWrite;
  633.  
  634.  
  635. PROCEDURE ScrpClear; 
  636. BEGIN
  637.  CallResult:= AESCall(82, 0, 1, 0, 0);
  638. END ScrpClear;
  639.  
  640.  
  641. (*#######################################################################*)
  642.  
  643. PROCEDURE ShelRead (VAR command, path: ARRAY OF CHAR);
  644. BEGIN
  645.  AESAddrIn[0]:= ADR(command);
  646.  AESAddrIn[1]:= ADR(path);
  647.  CallResult:= AESCall(120, 0, 1, 2, 0);
  648. END ShelRead;
  649.  
  650.  
  651. PROCEDURE ShelWrite (exec, appl, start: sINTEGER; command, path: ARRAY OF CHAR);
  652. BEGIN
  653.  AESIntIn[0]:=  exec;
  654.  AESIntIn[1]:=  appl;
  655.  AESIntIn[2]:=  start;
  656.  AESAddrIn[0]:= ADR(command);
  657.  AESAddrIn[1]:= ADR(path);
  658.  CallResult:= AESCall(121, 3, 1, 2, 0);
  659. END ShelWrite;
  660.  
  661.  
  662. PROCEDURE ShelGet (len: sINTEGER; VAR buffer: ARRAY OF LOC);
  663. BEGIN
  664.  AESIntIn[0]:=  len;
  665.  AESAddrIn[0]:= ADR(buffer);
  666.  CallResult:= AESCall(122, 1, 1, 1, 0);
  667. END ShelGet;
  668.  
  669.  
  670. PROCEDURE ShelPut (len: sINTEGER; VAR buffer: ARRAY OF LOC);
  671. BEGIN
  672.  AESIntIn[0]:=  len;
  673.  AESAddrIn[0]:= ADR(buffer);
  674.  CallResult:= AESCall(123, 1, 1, 1, 0);
  675. END ShelPut;
  676.  
  677.  
  678. PROCEDURE ShelFind (VAR name: ARRAY OF CHAR);
  679. BEGIN
  680.  AESAddrIn[0]:= ADR(name);
  681.  CallResult:= AESCall(124, 0, 1, 1, 0);
  682. END ShelFind;
  683.  
  684.  
  685. PROCEDURE ShelEnvrn (VAR param: ARRAY OF CHAR; name: ARRAY OF CHAR);
  686. BEGIN
  687.  AESAddrIn[0]:= ADR(param);
  688.  AESAddrIn[1]:= ADR(name);
  689.  CallResult:= AESCall(125, 0, 1, 2, 0);
  690. END ShelEnvrn;
  691.  
  692.  
  693. PROCEDURE ShelRdef (command, path: ARRAY OF CHAR);
  694. (* Erst ab GEM 2.0 *)
  695. BEGIN
  696.  AESAddrIn[0]:= ADR(command);
  697.  AESAddrIn[1]:= ADR(path);
  698.  CallResult:= AESCall(126, 0, 1, 2, 0);
  699. END ShelRdef;
  700.  
  701.  
  702. PROCEDURE ShelWdef (command, path: ARRAY OF CHAR);
  703. (* Erst ab GEM 2.0 *)
  704. BEGIN
  705.  AESAddrIn[0]:= ADR(command);
  706.  AESAddrIn[1]:= ADR(path);
  707.  CallResult:= AESCall(127, 0, 1, 2, 0);
  708. END ShelWdef;
  709.  
  710.  
  711. (*#######################################################################*)
  712.  
  713. PROCEDURE WindCreate (comp: sBITSET; size: ARRAY OF LOC): sINTEGER;
  714. BEGIN
  715.  AESIntIn[ 0]:= CastToInt (comp);
  716.  array:= ADR(size);
  717.  AESIntIn[ 1]:= array^[0];
  718.  AESIntIn[ 2]:= array^[1];
  719.  AESIntIn[ 3]:= array^[2];
  720.  AESIntIn[ 4]:= array^[3];
  721.  RETURN AESCall(100, 5, 1, 0, 0);
  722. END WindCreate;
  723.  
  724.  
  725. PROCEDURE WindOpen   (handle: sINTEGER; size: ARRAY OF LOC);
  726. BEGIN
  727.  AESIntIn[ 0]:= handle;
  728.  array:= ADR(size);
  729.  AESIntIn[ 1]:= array^[0];
  730.  AESIntIn[ 2]:= array^[1];
  731.  AESIntIn[ 3]:= array^[2];
  732.  AESIntIn[ 4]:= array^[3];
  733.  CallResult:= AESCall(101, 5, 1, 0, 0);
  734. END WindOpen;
  735.  
  736.  
  737. PROCEDURE WindClose  (handle: sINTEGER);
  738. BEGIN
  739.  AESIntIn[ 0]:= handle;
  740.  CallResult:= AESCall(102, 1, 1, 0, 0);
  741. END WindClose;
  742.  
  743.  
  744. PROCEDURE WindDelete (handle: sINTEGER);
  745. BEGIN
  746.  AESIntIn[ 0]:= handle;
  747.  CallResult:= AESCall(103, 1, 1, 0, 0);
  748. END WindDelete;
  749.  
  750.  
  751. PROCEDURE WindGet (handle, flag: sINTEGER; VAR para: ARRAY OF LOC);
  752. BEGIN
  753.  AESIntIn[ 0]:= handle;
  754.  AESIntIn[ 1]:= flag;
  755.  CallResult:= AESCall(104, 2, 5, 0, 0);
  756.  array:= ADR(para);
  757.  array^[0]:= AESIntOut[ 1];
  758.  array^[1]:= AESIntOut[ 2];
  759.  array^[2]:= AESIntOut[ 3];
  760.  array^[3]:= AESIntOut[ 4];
  761. END WindGet;
  762.  
  763.  
  764. PROCEDURE WindSet (handle, flag: sINTEGER; para: ARRAY OF LOC);
  765. BEGIN
  766.  AESIntIn[ 0]:= handle;
  767.  AESIntIn[ 1]:= flag;
  768.  array:= ADR(para);
  769.  AESIntIn[ 2]:= array^[0];
  770.  AESIntIn[ 3]:= array^[1];
  771.  AESIntIn[ 4]:= array^[2];
  772.  AESIntIn[ 5]:= array^[3];
  773.  CallResult:= AESCall(105, 6, 1, 0, 0);
  774. END WindSet;
  775.  
  776.  
  777. PROCEDURE WindFind (x, y: sINTEGER): sINTEGER;
  778. BEGIN
  779.  AESIntIn[ 0]:= x;
  780.  AESIntIn[ 1]:= y;
  781.  RETURN AESCall(106, 2, 1, 0, 0);
  782. END WindFind;
  783.  
  784.  
  785. PROCEDURE WindUpdate (mode: sINTEGER);
  786. BEGIN
  787.  AESIntIn[ 0]:= mode;
  788.  CallResult:= AESCall(107, 1, 1, 0, 0);
  789. END WindUpdate;
  790.  
  791.  
  792. PROCEDURE WindCalc (what: sINTEGER; comp: sBITSET; VAR in, out: ARRAY OF LOC); 
  793. BEGIN
  794.  AESIntIn[ 0]:= what;
  795.  AESIntIn[ 1]:= CastToInt (comp);
  796.  array:= ADR(in);
  797.  AESIntIn[ 2]:= array^[0];
  798.  AESIntIn[ 3]:= array^[1];
  799.  AESIntIn[ 4]:= array^[2];
  800.  AESIntIn[ 5]:= array^[3];
  801.  CallResult:= AESCall(108, 6, 5, 0, 0);
  802.  array:= ADR(out);
  803.  array^[0]:= AESIntOut[ 1];
  804.  array^[1]:= AESIntOut[ 2];
  805.  array^[2]:= AESIntOut[ 3];
  806.  array^[3]:= AESIntOut[ 4];
  807. END WindCalc;
  808.  
  809.  
  810. PROCEDURE WindNew;
  811. BEGIN
  812.  CallResult:= AESCall(109, 0, 0, 0, 0);
  813. END WindNew;
  814.  
  815.  
  816. (*#######################################################################*)
  817.  
  818. PROCEDURE ObjcAdd (tree: ADDRESS; parent, child: sINTEGER);
  819. BEGIN
  820.  AESIntIn[ 0]:= parent;
  821.  AESIntIn[ 1]:= child;
  822.  AESAddrIn[0]:= tree;
  823.  CallResult:= AESCall(40, 2, 1, 1, 0);
  824. END ObjcAdd;
  825.  
  826.  
  827. PROCEDURE ObjcDelete (tree: ADDRESS; object: sINTEGER);
  828. BEGIN
  829.  AESIntIn[ 0]:= object;
  830.  AESAddrIn[0]:= tree;
  831.  CallResult:= AESCall(41, 1, 1, 1, 0);
  832. END ObjcDelete;
  833.  
  834.  
  835. PROCEDURE ObjcDraw (tree: ADDRESS; start, depth: sINTEGER; pxy: ARRAY OF LOC);
  836. BEGIN
  837.  AESIntIn[ 0]:= start;
  838.  AESIntIn[ 1]:= depth;
  839.  array:= ADR(pxy);
  840.  AESIntIn[ 2]:= array^[0];
  841.  AESIntIn[ 3]:= array^[1];
  842.  AESIntIn[ 4]:= array^[2];
  843.  AESIntIn[ 5]:= array^[3];
  844.  AESAddrIn[0]:= tree;
  845.  CallResult:= AESCall(42, 6, 1, 1, 0);
  846. END ObjcDraw;
  847.  
  848.  
  849. PROCEDURE ObjcFind (tree: ADDRESS; start, depth, x, y: sINTEGER): sINTEGER;
  850. BEGIN
  851.  AESIntIn[ 0]:= start;
  852.  AESIntIn[ 1]:= depth;
  853.  AESIntIn[ 2]:= x;
  854.  AESIntIn[ 3]:= y;
  855.  AESAddrIn[0]:= tree;
  856.  RETURN AESCall(43, 4, 1, 1, 0);
  857. END ObjcFind;
  858.  
  859.  
  860. PROCEDURE ObjcOffset (tree: ADDRESS; object: sINTEGER; VAR x, y: sINTEGER);
  861. BEGIN
  862.  AESIntIn[ 0]:= object;
  863.  AESAddrIn[0]:= tree;
  864.  CallResult:= AESCall(44, 1, 3, 1, 0);
  865.  x:= AESIntOut[1];
  866.  y:= AESIntOut[2];
  867. END ObjcOffset;
  868.  
  869.  
  870. PROCEDURE ObjcOrder (tree: ADDRESS; object, newpos: sINTEGER);
  871. BEGIN
  872.  AESIntIn[ 0]:= object;
  873.  AESIntIn[ 1]:= newpos;
  874.  AESAddrIn[0]:= tree;
  875.  CallResult:= AESCall(45, 2, 1, 1, 0);
  876. END ObjcOrder;
  877.  
  878.  
  879. PROCEDURE ObjcEdit (tree: ADDRESS; object: sINTEGER; VAR pos: sINTEGER;
  880.                   char, kind: sINTEGER);
  881. BEGIN
  882.  AESIntIn[ 0]:= object;
  883.  AESIntIn[ 1]:= char;
  884.  AESIntIn[ 2]:= pos;
  885.  AESIntIn[ 3]:= kind;
  886.  AESAddrIn[0]:= tree;
  887.  CallResult:= AESCall(46, 4, 2, 1, 0);
  888.  pos:= AESIntOut[1];
  889. END ObjcEdit;
  890.  
  891.  
  892. PROCEDURE ObjcChange (tree: ADDRESS; object: sINTEGER; pxy: ARRAY OF LOC;
  893.                   state: sBITSET; mode: sINTEGER);
  894. BEGIN
  895.  AESIntIn[ 0]:= object;
  896.  AESIntIn[ 1]:= 0;
  897.  array:= ADR(pxy);
  898.  AESIntIn[ 2]:= array^[0];
  899.  AESIntIn[ 3]:= array^[1];
  900.  AESIntIn[ 4]:= array^[2];
  901.  AESIntIn[ 5]:= array^[3];
  902.  AESIntIn[ 6]:= CastToInt (state);
  903.  AESIntIn[ 7]:= mode;
  904.  AESAddrIn[0]:= tree;
  905.  CallResult:= AESCall(47, 8, 1, 1, 0);
  906. END ObjcChange;
  907.  
  908.  
  909. (*#######################################################################*)
  910.  
  911. PROCEDURE XgrfStepcalc (ow, oh, x, y, w, h: sINTEGER;
  912.                         VAR cx, cy, count, xstep, ystep: sINTEGER);
  913. BEGIN
  914.  AESIntIn[ 0]:= ow;
  915.  AESIntIn[ 1]:= oh;
  916.  AESIntIn[ 2]:= x;
  917.  AESIntIn[ 3]:= y;
  918.  AESIntIn[ 4]:= w;
  919.  AESIntIn[ 5]:= h;
  920.  CallResult:= AESCall(130, 6, 6, 0, 0);
  921.  cx:=    AESIntOut[ 1];
  922.  cy:=    AESIntOut[ 2];
  923.  count:= AESIntOut[ 3];
  924.  xstep:= AESIntOut[ 4];
  925.  ystep:= AESIntOut[ 5]; 
  926. END XgrfStepcalc;
  927.  
  928.  
  929. PROCEDURE Xgrf2box (xc, yc, wc, hc, corners, count, xstep, ystep, doubled: sINTEGER);
  930. BEGIN
  931.  AESIntIn[ 0]:= count; 
  932.  AESIntIn[ 1]:= xstep; 
  933.  AESIntIn[ 2]:= ystep; 
  934.  AESIntIn[ 3]:= doubled; 
  935.  AESIntIn[ 4]:= corners; 
  936.  AESIntIn[ 5]:= xc; 
  937.  AESIntIn[ 6]:= yc; 
  938.  AESIntIn[ 7]:= wc; 
  939.  AESIntIn[ 8]:= hc; 
  940.  CallResult:= AESCall(131, 9, 1, 0, 0);
  941. END Xgrf2box;
  942.  
  943.  
  944.  
  945. BEGIN
  946.  AESGlobal.apPtree:= Null;
  947.  WITH AESPB DO
  948.   cbControl:=  ADR (AESControl);
  949.   cbPglobal:=  ADR (AESGlobal);
  950.   cbPintin:=   ADR (AESIntIn);
  951.   cbPintout:=  ADR (AESIntOut);
  952.   cbPadrin:=   ADR (AESAddrIn);
  953.   cbPadrout:=  ADR (AESAddrOut);
  954.  END;
  955.  aespb:= ADR(AESPB);
  956. END MagicAES.
  957.  
  958.