(*######################################################################
                                                                        
  MAGIC         Modula's  All purpose  GEM  Interface  Cadre
                ˙         ˙            ˙    ˙          ˙
########################################################################

  AES   Application Environment Services        Interface for Modula-2

########################################################################
  V2.01 24.10.90  Peter Hellinger   Systemaufrufe nach MagicSys ver-
                                    lagert, dadurch ist MagicAES
                                    fast unabh„ngig vom Compiler.
  V2.00 16.10.90  Peter Hellinger   Anpassung an neues MagicSys
  V1.04 05.08.90  Peter Hellinger
  V1.01 18.06.90  Peter Hellinger   Xgraf-Funktionen implementiert
  V1.00 (C) by    Peter Hellinger
######################################################################*)

IMPLEMENTATION MODULE MagicAES;

(*------------------------------*)
(*       COMPILERSWITCHES       *)
(*------------------------------*)
(* TDI-Version:   DEAKTIVIERT   *)
(*------------------------------*)
(* V-  Overflow-Checks          *)
(* R-  Range-Checks             *)
(* S-  Stack-Check              *)
(* N-  NIL-Checks               *)
(* T-  TDI-Compiler vor 3.01    *)
(* Q+  Branch statt Jumps       *)
(*                              *)
(*------------------------------*)
(* MM2-Version:     AKTIVIERT   *)
(*------------------------------*)
(*$R-   Range-Checks            *)
(*$S-   Stack-Check             *)
(*                              *)
(*------------------------------*)


FROM SYSTEM     IMPORT  ADDRESS, ADR;
FROM MagicSys   IMPORT  Nil, Null, Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7,
                        Bit8, Bit9, Bit10, Bit11, Bit12, Bit13, Bit14, Bit15,
                        LOC, Byte, ByteSet, sWORD, sINTEGER, sCARDINAL, sBITSET,
                        lWORD, lINTEGER, lCARDINAL, lBITSET,
                        CastToChar, CastToByte, CastToByteset, CastToInt,
                        CastToCard, CastToBitset, CastToWord, CastToLInt,
                        CastToLCard, CastToLBitset, CastToLWord, CastToAddr,
                        CallGEM;


VAR array:  POINTER TO ARRAY [0..255] OF sINTEGER;
    aespb:  ADDRESS; (* Adresse des AES-Parameterblocks *)


(*#######################################################################*)


PROCEDURE AESCall (op, c1, c2, c3, c4: sINTEGER): sINTEGER;
BEGIN
 WITH AESControl DO
  opcode:= op;
  sizeIntIn:= c1;
  sizeIntOut:= c2;
  sizeAddrIn:= c3;
  sizeAddrOut:= c4;
 END;
 CallGEM (200, aespb);
 CallResult:= AESIntOut[0];
 RETURN CallResult;
END AESCall;


PROCEDURE ApplInit(): sINTEGER;
BEGIN
 RETURN AESCall(10, 0, 1, 0, 0);
END ApplInit;


PROCEDURE ApplRead (id, len: sINTEGER; VAR pipe: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:=  id;
 AESIntIn[ 1]:=  len;
 AESAddrIn[ 0]:= ADR(pipe);
 CallResult:= AESCall(11, 2, 1, 1, 0);
END ApplRead;


PROCEDURE ApplWrite (id, len: sINTEGER; VAR pipe: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:=  id;
 AESIntIn[ 1]:=  len;
 AESAddrIn[ 0]:= ADR(pipe);
 CallResult:= AESCall(12, 2, 1, 1, 0);
END ApplWrite;


PROCEDURE ApplFind (name: ARRAY OF CHAR): sINTEGER;
BEGIN
 AESAddrIn[ 0]:= ADR(name);
 RETURN AESCall(13, 0, 1, 1, 0);
END ApplFind;


PROCEDURE ApplTplay (num, speed: sINTEGER; VAR buffer: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:=  num;
 AESIntIn[ 1]:=  speed;
 AESAddrIn[ 0]:= ADR(buffer);
 CallResult:= AESCall(14, 2, 1, 1, 0);
END ApplTplay;


PROCEDURE ApplTrecord (count: sINTEGER; VAR buffer: ARRAY OF LOC): sINTEGER;
BEGIN
 AESIntIn[ 0]:=  count;
 AESAddrIn[ 0]:= ADR(buffer);
 RETURN AESCall(15, 1, 1, 1, 0);
END ApplTrecord;


PROCEDURE ApplBvset (disk, hard: sBITSET);
BEGIN
 AESIntIn[ 0]:= CastToInt (disk);
 AESIntIn[ 1]:= CastToInt (hard);
 CallResult:= AESCall(16, 2, 1, 1, 0);
END ApplBvset;


PROCEDURE ApplYield;
BEGIN
 CallResult:= AESCall(17, 0, 1, 0, 0);
END ApplYield;


PROCEDURE ApplExit;
BEGIN
 CallResult:= AESCall(19, 0, 1, 0, 0);
END ApplExit;


PROCEDURE EvntKeybd (VAR key, scan: sINTEGER;  VAR chr: CHAR);
VAR split: RECORD
            CASE: BOOLEAN OF
             TRUE: wert: sINTEGER;|
             FALSE: hi: CHAR;
                    lo: CHAR;|
            END;
           END;
BEGIN
 split.wert:= AESCall(20, 0, 1, 0, 0); (* Auf Keyboard-Event warten *)
 key:= split.wert;
 scan:= ORD (split.hi);
 chr:= split.lo;
END EvntKeybd;


PROCEDURE EvntMulti (which: sBITSET;  maxclicks: sINTEGER;  mask, state: sBITSET;
                     m1mode: sINTEGER;  m1rect: ARRAY OF LOC;
                     m2mode: sINTEGER;  m2rect: ARRAY OF LOC;
                     VAR msgBuff: ARRAY OF LOC;
                     loTimer, hiTimer: sINTEGER;
                     VAR x, y: sINTEGER;
                     VAR button: sBITSET;
                     VAR taste: sINTEGER;
                     VAR kbshift: sBITSET;
                     VAR scan: sINTEGER;
                     VAR ascii: CHAR;
                     VAR clicks: sINTEGER): sBITSET;
VAR split: RECORD
            CASE: BOOLEAN OF
             TRUE: wert: sINTEGER;|
             FALSE: hi: CHAR;
                    lo: CHAR;|
            END;
           END;
VAR event: sBITSET;
BEGIN (* multi *)
 (* Array's laden *)
 AESIntIn[ 0]:= CastToInt (which);
 AESIntIn[ 1]:= maxclicks;
 AESIntIn[ 2]:= CastToInt (mask);
 AESIntIn[ 3]:= CastToInt (state);
 AESIntIn[ 4]:= m1mode;
 array:= ADR (m1rect);
 AESIntIn[ 5]:= array^[0];
 AESIntIn[ 6]:= array^[1];
 AESIntIn[ 7]:= array^[2];
 AESIntIn[ 8]:= array^[3];
 AESIntIn[ 9]:= m2mode;
 array:= ADR (m2rect);
 AESIntIn[10]:= array^[0];
 AESIntIn[11]:= array^[1];
 AESIntIn[12]:= array^[2];
 AESIntIn[13]:= array^[3];
 AESIntIn[14]:= loTimer;
 AESIntIn[15]:= hiTimer;
 AESAddrIn[0]:= ADR(msgBuff);

 CallResult:= AESCall(25, 16, 7, 1, 0);
 event:= CastToBitset (CallResult);

 x:= AESIntOut[1];
 y:= AESIntOut[2];
 button:= CastToBitset (AESIntOut[3]);
 kbshift:= CastToBitset (AESIntOut[4]);
 split.wert:= AESIntOut[5];
 taste:= split.wert;
 scan:= ORD (split.hi);
 ascii:= split.lo;
 clicks:= AESIntOut[6];

 RETURN event;
END EvntMulti;


PROCEDURE EvntPmulti (): sBITSET;
BEGIN
 CallResult:= AESCall(25, 16, 7, 1, 0);
 RETURN CastToBitset (CallResult);
END EvntPmulti;


PROCEDURE EvntButton (maxclicks: sINTEGER; mask, state: sBITSET;
                      VAR x, y: sINTEGER;  VAR button, kbshift: sBITSET): sINTEGER;
VAR clicks: sINTEGER;
BEGIN
 AESIntIn[ 0]:= maxclicks;
 AESIntIn[ 1]:= CastToInt (mask);
 AESIntIn[ 1]:= CastToInt (state);
 clicks:= AESCall(21, 3, 5, 0, 0);
 x:= AESIntOut[1];
 y:= AESIntOut[2];
 button:= CastToBitset (AESIntOut[3]);
 kbshift:= CastToBitset (AESIntOut[4]);
 RETURN clicks;
END EvntButton;


PROCEDURE EvntMouse  (mode: sINTEGER;  VAR m1rect: ARRAY OF LOC;
                      VAR x, y: sINTEGER;  VAR button, kbshift: sBITSET);
BEGIN
 AESIntIn[ 0]:= mode;
 array:= ADR (m1rect);
 AESIntIn[ 1]:= array^[0];
 AESIntIn[ 2]:= array^[1];
 AESIntIn[ 3]:= array^[2];
 AESIntIn[ 4]:= array^[3];
 CallResult:= AESCall(22, 5, 5, 0, 0);
 x:= AESIntOut[1];
 y:= AESIntOut[2];
 button:=  CastToBitset (AESIntOut[3]);
 kbshift:= CastToBitset (AESIntOut[4]);
END EvntMouse;


PROCEDURE EvntMesag (VAR buffer: ARRAY OF LOC);
BEGIN
 AESAddrIn[0]:= ADR(buffer);
 CallResult:= AESCall(23, 0, 1, 1, 0);
END EvntMesag;


PROCEDURE EvntTimer (count: LONGCARD);
VAR trick: RECORD
            CASE : BOOLEAN OF
             TRUE: long: lCARDINAL;|
             FALSE: hi, lo: sINTEGER;|
            END;
           END;
BEGIN
 trick.long:= count;
 AESIntIn[ 0]:= trick.lo;
 AESIntIn[ 1]:= trick.hi;
 CallResult:= AESCall(24, 2, 1, 0, 0);
END EvntTimer;


PROCEDURE EvntDclicks (new: sINTEGER; set: BOOLEAN): sINTEGER;
BEGIN
 AESIntIn[ 0]:= new;
 IF set THEN  AESIntIn[ 1]:= 1;  ELSE  AESIntIn[ 1]:= 0;  END;
 RETURN AESCall(26, 2, 1, 0, 0);
END EvntDclicks;


(*######################################################################*)


PROCEDURE FormDo (tree: ADDRESS; start: sINTEGER): sINTEGER;
BEGIN
 AESIntIn[ 0]:= start;
 AESAddrIn[0]:= tree;
 RETURN AESCall(50, 1, 1, 1, 0);
END FormDo;


PROCEDURE FormDial (flag: sINTEGER; small, big: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:= flag;
 array:= ADR(small);
 AESIntIn[ 1]:= array^[0];
 AESIntIn[ 2]:= array^[1];
 AESIntIn[ 3]:= array^[2];
 AESIntIn[ 4]:= array^[3];
 array:= ADR(big);
 AESIntIn[ 5]:= array^[0];
 AESIntIn[ 6]:= array^[1];
 AESIntIn[ 7]:= array^[2];
 AESIntIn[ 8]:= array^[3];
 CallResult:= AESCall(51, 9, 1, 1, 0);
END FormDial;


PROCEDURE FormAlert  (button: sINTEGER; string: ARRAY OF CHAR): sINTEGER;
BEGIN
 AESIntIn[ 0]:= button;
 AESAddrIn[0]:= ADR(string);
 RETURN AESCall(52, 1, 1, 1, 0);
END FormAlert;


PROCEDURE FormError  (errNum: sINTEGER);
BEGIN
 AESIntIn[ 0]:= errNum;
 CallResult:= AESCall(53, 1, 1, 0, 0);
END FormError;


PROCEDURE FormCenter (tree: ADDRESS; VAR rect: ARRAY OF LOC);
BEGIN
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(54, 0, 5, 1, 0);
 array:= ADR(rect);
 array^[0]:= AESIntOut[1];
 array^[1]:= AESIntOut[2];
 array^[2]:= AESIntOut[3];
 array^[3]:= AESIntOut[4];
END FormCenter;


PROCEDURE FormKeybd (tree: ADDRESS;  object, chIn: sINTEGER;
                     VAR next, chOut: sINTEGER): sINTEGER;
BEGIN
 AESIntIn[ 0]:= object;
 AESIntIn[ 1]:= chIn;
 AESIntIn[ 2]:= 0;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(55, 3, 3, 1, 0);
 next:= AESIntOut[1];
 chOut:= AESIntOut[2];
 RETURN CallResult;  
END FormKeybd;


PROCEDURE FormButton (tree: ADDRESS; obj, cl: sINTEGER; VAR next: sINTEGER): sINTEGER;
BEGIN
 AESIntIn[ 0]:= obj;
 AESIntIn[ 1]:= cl;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(56, 2, 2, 1, 0);
 next:= AESIntOut[1];
 RETURN CallResult;
END FormButton;


(*#######################################################################*)

PROCEDURE FselInput (VAR pfad, name: ARRAY OF CHAR): BOOLEAN;
BEGIN
 AESAddrIn[0]:= ADR(pfad);
 AESAddrIn[1]:= ADR(name);
 CallResult:= AESCall(90, 0, 2, 2, 0);
 RETURN AESIntOut[1] = 1;
END FselInput;


PROCEDURE FselExinput (VAR info, pfad, name: ARRAY OF CHAR): BOOLEAN;
BEGIN
 AESAddrIn[0]:= ADR(pfad);
 AESAddrIn[1]:= ADR(name);
 AESAddrIn[2]:= ADR(info);
 CallResult:= AESCall(91, 0, 2, 3, 0);
 RETURN AESIntOut[1] = 1;
END FselExinput;


(*#######################################################################*)

PROCEDURE GrafRubberbox (x, y, mw, mh: sINTEGER; VAR lw, lh: sINTEGER);
BEGIN
 AESIntIn[ 0]:= x;
 AESIntIn[ 1]:= y;
 AESIntIn[ 2]:= mw;
 AESIntIn[ 3]:= mh;
 CallResult:= AESCall(70, 4, 3, 0, 0);
 lw:= AESIntOut[1];
 lh:= AESIntOut[2];
END GrafRubberbox;


PROCEDURE GrafDragbox (moving, boundary: ARRAY OF LOC; VAR x, y: sINTEGER);
BEGIN
 array:= ADR(moving);
 AESIntIn[ 0]:= array^[2];
 AESIntIn[ 1]:= array^[3];
 AESIntIn[ 2]:= array^[0];
 AESIntIn[ 3]:= array^[1];
 array:= ADR(boundary);
 AESIntIn[ 4]:= array^[0];
 AESIntIn[ 5]:= array^[1];
 AESIntIn[ 6]:= array^[2];
 AESIntIn[ 7]:= array^[3];
 CallResult:= AESCall(71, 8, 3, 0, 0);
 x:= AESIntOut[1];
 y:= AESIntOut[2];
END GrafDragbox;


PROCEDURE GrafMovebox (rect: ARRAY OF LOC; dx, dy: sINTEGER);
BEGIN
 array:= ADR(rect);
 AESIntIn[ 0]:= array^[0];
 AESIntIn[ 1]:= array^[1];
 AESIntIn[ 2]:= array^[2];
 AESIntIn[ 3]:= array^[3];
 AESIntIn[ 4]:= dx;
 AESIntIn[ 5]:= dy;
 CallResult:= AESCall(72, 6, 1, 0, 0);
END GrafMovebox;


PROCEDURE GrafGrowbox (source, dest: ARRAY OF LOC);
BEGIN
 array:= ADR(source);
 AESIntIn[ 0]:= array^[0];
 AESIntIn[ 1]:= array^[1];
 AESIntIn[ 2]:= array^[2];
 AESIntIn[ 3]:= array^[3];
 array:= ADR(dest);
 AESIntIn[ 4]:= array^[0];
 AESIntIn[ 5]:= array^[1];
 AESIntIn[ 6]:= array^[2];
 AESIntIn[ 7]:= array^[3];
 CallResult:= AESCall(73, 8, 1, 0, 0);
END GrafGrowbox;


PROCEDURE GrafShrinkbox (source, dest: ARRAY OF LOC);
BEGIN
 array:= ADR(source);
 AESIntIn[ 0]:= array^[0];
 AESIntIn[ 1]:= array^[1];
 AESIntIn[ 2]:= array^[2];
 AESIntIn[ 3]:= array^[3];
 array:= ADR(dest);
 AESIntIn[ 4]:= array^[0];
 AESIntIn[ 5]:= array^[1];
 AESIntIn[ 6]:= array^[2];
 AESIntIn[ 7]:= array^[3];
 CallResult:= AESCall(74, 8, 1, 0, 0);
END GrafShrinkbox;


PROCEDURE GrafWatchbox (tree: ADDRESS; item: sINTEGER; in, out: sBITSET): sINTEGER;
BEGIN
 AESIntIn[1]:= item;
 AESIntIn[2]:= CastToInt (in);
 AESIntIn[3]:= CastToInt (out);
 AESAddrIn[0]:= tree;
 RETURN AESCall(75, 4, 1, 0, 0);
END GrafWatchbox;


PROCEDURE GrafSlidebox (tree: ADDRESS; parent, object, dir: sINTEGER): sINTEGER;
BEGIN
 AESIntIn[ 0]:= parent;
 AESIntIn[ 1]:= object;
 AESIntIn[ 2]:= dir;
 AESAddrIn[ 0]:= tree;
 RETURN AESCall(76, 3, 1, 0, 0);
END GrafSlidebox;


PROCEDURE GrafHandle (VAR handle, cw, ch, bw, bh: sINTEGER);
BEGIN
 CallResult:= AESCall(77, 0, 5, 0, 0);
 handle:= AESIntOut[0];
 cw:= AESIntOut[1];
 ch:= AESIntOut[2];
 bw:= AESIntOut[3];
 bh:= AESIntOut[4];
END GrafHandle;


PROCEDURE GrafMouse (form: sINTEGER; user: ADDRESS);
BEGIN
 AESIntIn[0]:= form;
 AESAddrIn[ 0]:= user;
 CallResult:= AESCall(78, 1, 1, 0, 0);
END GrafMouse;


PROCEDURE GrafMkstate (VAR x, y: sINTEGER; VAR button, key: sBITSET);
BEGIN
 CallResult:= AESCall(79, 0, 5, 0, 0);
 x:= AESIntOut[1];
 y:= AESIntOut[2];
 button:= CastToBitset (AESIntOut[3]);
 key:= CastToBitset (AESIntOut[4]);
END GrafMkstate;


(*#######################################################################*)

PROCEDURE MenuBar (tree: ADDRESS; action: sINTEGER);
BEGIN
 AESIntIn[ 0]:= action;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(30, 1, 1, 1, 0);
END MenuBar;


PROCEDURE MenuIcheck (tree: ADDRESS; item: sINTEGER; action: sINTEGER);
BEGIN
 AESIntIn[ 0]:= item;
 AESIntIn[ 1]:= action;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(31, 2, 1, 1, 0);
END MenuIcheck;


PROCEDURE MenuIenable (tree: ADDRESS; item: sINTEGER; action: sINTEGER);
BEGIN
 AESIntIn[ 0]:= item;
 AESIntIn[ 1]:= action;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(32, 2, 1, 1, 0);
END MenuIenable;


PROCEDURE MenuTnormal (tree: ADDRESS; item: sINTEGER; action: sINTEGER);
BEGIN
 AESIntIn[ 0]:= item;
 AESIntIn[ 1]:= action;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(33, 2, 1, 1, 0);
END MenuTnormal;


PROCEDURE MenuText (tree: ADDRESS; item: sINTEGER; str: ARRAY OF CHAR);
BEGIN
 AESIntIn[ 0]:= item;
 AESAddrIn[0]:= tree;
 AESAddrIn[1]:= ADR(str);
 CallResult:= AESCall(34, 1, 1, 2, 0);
END MenuText;


PROCEDURE MenuRegister (apid: sINTEGER; str: ARRAY OF CHAR);
BEGIN
 AESIntIn[ 0]:= apid;
 AESAddrIn[0]:= ADR(str);
 CallResult:= AESCall(35, 1, 1, 1, 0);
END MenuRegister;


PROCEDURE MenuUnregister (apid: sINTEGER);
BEGIN
 AESIntIn[ 0]:= apid;
 CallResult:= AESCall(36, 1, 1, 1, 0);
END MenuUnregister;


(*#######################################################################*)

PROCEDURE RsrcLoad (name: ARRAY OF CHAR): BOOLEAN;
BEGIN
 AESAddrIn[ 0]:= ADR(name);
 CallResult:= AESCall(110, 0, 1, 1, 0);
 RETURN CallResult # 0;
END RsrcLoad;


PROCEDURE RsrcFree;
BEGIN
 CallResult:= AESCall(111, 0, 1, 0, 0);
END RsrcFree;


PROCEDURE RsrcGaddr (type, item: sINTEGER): ADDRESS;
BEGIN
 AESIntIn[ 0]:= type;
 AESIntIn[ 1]:= item;
 CallResult:= AESCall(112, 2, 1, 0, 1);
 RETURN  AESAddrOut[0];
END RsrcGaddr;


PROCEDURE RsrcSaddr (type, item: sINTEGER; adr: ADDRESS);
BEGIN
 AESIntIn[ 0]:= type;
 AESIntIn[ 1]:= item;
 AESAddrIn[0]:= adr;
 CallResult:= AESCall(113, 2, 1, 1, 0);
END RsrcSaddr;


PROCEDURE RsrcObfix (tree: ADDRESS; object: sINTEGER);
BEGIN
 AESIntIn[ 0]:= object;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(114, 1, 1, 1, 0);
END RsrcObfix;


(*#######################################################################*)

PROCEDURE ScrpRead (VAR pfad: ARRAY OF CHAR): sBITSET;
BEGIN
 AESAddrIn[0]:= ADR(pfad);
 CallResult:= AESCall(80, 0, 1, 1, 0);
 RETURN CastToBitset (CallResult);
END ScrpRead;


PROCEDURE ScrpWrite (pfad: ARRAY OF CHAR);
BEGIN
 AESAddrIn[0]:= ADR(pfad);
 CallResult:= AESCall(81, 0, 1, 1, 0);
END ScrpWrite;


PROCEDURE ScrpClear; 
BEGIN
 CallResult:= AESCall(82, 0, 1, 0, 0);
END ScrpClear;


(*#######################################################################*)
 
PROCEDURE ShelRead (VAR command, path: ARRAY OF CHAR);
BEGIN
 AESAddrIn[0]:= ADR(command);
 AESAddrIn[1]:= ADR(path);
 CallResult:= AESCall(120, 0, 1, 2, 0);
END ShelRead;


PROCEDURE ShelWrite (exec, appl, start: sINTEGER; command, path: ARRAY OF CHAR);
BEGIN
 AESIntIn[0]:=  exec;
 AESIntIn[1]:=  appl;
 AESIntIn[2]:=  start;
 AESAddrIn[0]:= ADR(command);
 AESAddrIn[1]:= ADR(path);
 CallResult:= AESCall(121, 3, 1, 2, 0);
END ShelWrite;


PROCEDURE ShelGet (len: sINTEGER; VAR buffer: ARRAY OF LOC);
BEGIN
 AESIntIn[0]:=  len;
 AESAddrIn[0]:= ADR(buffer);
 CallResult:= AESCall(122, 1, 1, 1, 0);
END ShelGet;


PROCEDURE ShelPut (len: sINTEGER; VAR buffer: ARRAY OF LOC);
BEGIN
 AESIntIn[0]:=  len;
 AESAddrIn[0]:= ADR(buffer);
 CallResult:= AESCall(123, 1, 1, 1, 0);
END ShelPut;


PROCEDURE ShelFind (VAR name: ARRAY OF CHAR);
BEGIN
 AESAddrIn[0]:= ADR(name);
 CallResult:= AESCall(124, 0, 1, 1, 0);
END ShelFind;


PROCEDURE ShelEnvrn (VAR param: ARRAY OF CHAR; name: ARRAY OF CHAR);
BEGIN
 AESAddrIn[0]:= ADR(param);
 AESAddrIn[1]:= ADR(name);
 CallResult:= AESCall(125, 0, 1, 2, 0);
END ShelEnvrn;


PROCEDURE ShelRdef (command, path: ARRAY OF CHAR);
(* Erst ab GEM 2.0 *)
BEGIN
 AESAddrIn[0]:= ADR(command);
 AESAddrIn[1]:= ADR(path);
 CallResult:= AESCall(126, 0, 1, 2, 0);
END ShelRdef;


PROCEDURE ShelWdef (command, path: ARRAY OF CHAR);
(* Erst ab GEM 2.0 *)
BEGIN
 AESAddrIn[0]:= ADR(command);
 AESAddrIn[1]:= ADR(path);
 CallResult:= AESCall(127, 0, 1, 2, 0);
END ShelWdef;


(*#######################################################################*)

PROCEDURE WindCreate (comp: sBITSET; size: ARRAY OF LOC): sINTEGER;
BEGIN
 AESIntIn[ 0]:= CastToInt (comp);
 array:= ADR(size);
 AESIntIn[ 1]:= array^[0];
 AESIntIn[ 2]:= array^[1];
 AESIntIn[ 3]:= array^[2];
 AESIntIn[ 4]:= array^[3];
 RETURN AESCall(100, 5, 1, 0, 0);
END WindCreate;


PROCEDURE WindOpen   (handle: sINTEGER; size: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:= handle;
 array:= ADR(size);
 AESIntIn[ 1]:= array^[0];
 AESIntIn[ 2]:= array^[1];
 AESIntIn[ 3]:= array^[2];
 AESIntIn[ 4]:= array^[3];
 CallResult:= AESCall(101, 5, 1, 0, 0);
END WindOpen;


PROCEDURE WindClose  (handle: sINTEGER);
BEGIN
 AESIntIn[ 0]:= handle;
 CallResult:= AESCall(102, 1, 1, 0, 0);
END WindClose;


PROCEDURE WindDelete (handle: sINTEGER);
BEGIN
 AESIntIn[ 0]:= handle;
 CallResult:= AESCall(103, 1, 1, 0, 0);
END WindDelete;


PROCEDURE WindGet (handle, flag: sINTEGER; VAR para: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:= handle;
 AESIntIn[ 1]:= flag;
 CallResult:= AESCall(104, 2, 5, 0, 0);
 array:= ADR(para);
 array^[0]:= AESIntOut[ 1];
 array^[1]:= AESIntOut[ 2];
 array^[2]:= AESIntOut[ 3];
 array^[3]:= AESIntOut[ 4];
END WindGet;


PROCEDURE WindSet (handle, flag: sINTEGER; para: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:= handle;
 AESIntIn[ 1]:= flag;
 array:= ADR(para);
 AESIntIn[ 2]:= array^[0];
 AESIntIn[ 3]:= array^[1];
 AESIntIn[ 4]:= array^[2];
 AESIntIn[ 5]:= array^[3];
 CallResult:= AESCall(105, 6, 1, 0, 0);
END WindSet;


PROCEDURE WindFind (x, y: sINTEGER): sINTEGER;
BEGIN
 AESIntIn[ 0]:= x;
 AESIntIn[ 1]:= y;
 RETURN AESCall(106, 2, 1, 0, 0);
END WindFind;


PROCEDURE WindUpdate (mode: sINTEGER);
BEGIN
 AESIntIn[ 0]:= mode;
 CallResult:= AESCall(107, 1, 1, 0, 0);
END WindUpdate;


PROCEDURE WindCalc (what: sINTEGER; comp: sBITSET; VAR in, out: ARRAY OF LOC); 
BEGIN
 AESIntIn[ 0]:= what;
 AESIntIn[ 1]:= CastToInt (comp);
 array:= ADR(in);
 AESIntIn[ 2]:= array^[0];
 AESIntIn[ 3]:= array^[1];
 AESIntIn[ 4]:= array^[2];
 AESIntIn[ 5]:= array^[3];
 CallResult:= AESCall(108, 6, 5, 0, 0);
 array:= ADR(out);
 array^[0]:= AESIntOut[ 1];
 array^[1]:= AESIntOut[ 2];
 array^[2]:= AESIntOut[ 3];
 array^[3]:= AESIntOut[ 4];
END WindCalc;


PROCEDURE WindNew;
BEGIN
 CallResult:= AESCall(109, 0, 0, 0, 0);
END WindNew;


(*#######################################################################*)

PROCEDURE ObjcAdd (tree: ADDRESS; parent, child: sINTEGER);
BEGIN
 AESIntIn[ 0]:= parent;
 AESIntIn[ 1]:= child;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(40, 2, 1, 1, 0);
END ObjcAdd;


PROCEDURE ObjcDelete (tree: ADDRESS; object: sINTEGER);
BEGIN
 AESIntIn[ 0]:= object;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(41, 1, 1, 1, 0);
END ObjcDelete;


PROCEDURE ObjcDraw (tree: ADDRESS; start, depth: sINTEGER; pxy: ARRAY OF LOC);
BEGIN
 AESIntIn[ 0]:= start;
 AESIntIn[ 1]:= depth;
 array:= ADR(pxy);
 AESIntIn[ 2]:= array^[0];
 AESIntIn[ 3]:= array^[1];
 AESIntIn[ 4]:= array^[2];
 AESIntIn[ 5]:= array^[3];
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(42, 6, 1, 1, 0);
END ObjcDraw;


PROCEDURE ObjcFind (tree: ADDRESS; start, depth, x, y: sINTEGER): sINTEGER;
BEGIN
 AESIntIn[ 0]:= start;
 AESIntIn[ 1]:= depth;
 AESIntIn[ 2]:= x;
 AESIntIn[ 3]:= y;
 AESAddrIn[0]:= tree;
 RETURN AESCall(43, 4, 1, 1, 0);
END ObjcFind;


PROCEDURE ObjcOffset (tree: ADDRESS; object: sINTEGER; VAR x, y: sINTEGER);
BEGIN
 AESIntIn[ 0]:= object;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(44, 1, 3, 1, 0);
 x:= AESIntOut[1];
 y:= AESIntOut[2];
END ObjcOffset;


PROCEDURE ObjcOrder (tree: ADDRESS; object, newpos: sINTEGER);
BEGIN
 AESIntIn[ 0]:= object;
 AESIntIn[ 1]:= newpos;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(45, 2, 1, 1, 0);
END ObjcOrder;


PROCEDURE ObjcEdit (tree: ADDRESS; object: sINTEGER; VAR pos: sINTEGER;
                  char, kind: sINTEGER);
BEGIN
 AESIntIn[ 0]:= object;
 AESIntIn[ 1]:= char;
 AESIntIn[ 2]:= pos;
 AESIntIn[ 3]:= kind;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(46, 4, 2, 1, 0);
 pos:= AESIntOut[1];
END ObjcEdit;


PROCEDURE ObjcChange (tree: ADDRESS; object: sINTEGER; pxy: ARRAY OF LOC;
                  state: sBITSET; mode: sINTEGER);
BEGIN
 AESIntIn[ 0]:= object;
 AESIntIn[ 1]:= 0;
 array:= ADR(pxy);
 AESIntIn[ 2]:= array^[0];
 AESIntIn[ 3]:= array^[1];
 AESIntIn[ 4]:= array^[2];
 AESIntIn[ 5]:= array^[3];
 AESIntIn[ 6]:= CastToInt (state);
 AESIntIn[ 7]:= mode;
 AESAddrIn[0]:= tree;
 CallResult:= AESCall(47, 8, 1, 1, 0);
END ObjcChange;


(*#######################################################################*)

PROCEDURE XgrfStepcalc (ow, oh, x, y, w, h: sINTEGER;
                        VAR cx, cy, count, xstep, ystep: sINTEGER);
BEGIN
 AESIntIn[ 0]:= ow;
 AESIntIn[ 1]:= oh;
 AESIntIn[ 2]:= x;
 AESIntIn[ 3]:= y;
 AESIntIn[ 4]:= w;
 AESIntIn[ 5]:= h;
 CallResult:= AESCall(130, 6, 6, 0, 0);
 cx:=    AESIntOut[ 1];
 cy:=    AESIntOut[ 2];
 count:= AESIntOut[ 3];
 xstep:= AESIntOut[ 4];
 ystep:= AESIntOut[ 5]; 
END XgrfStepcalc;


PROCEDURE Xgrf2box (xc, yc, wc, hc, corners, count, xstep, ystep, doubled: sINTEGER);
BEGIN
 AESIntIn[ 0]:= count; 
 AESIntIn[ 1]:= xstep; 
 AESIntIn[ 2]:= ystep; 
 AESIntIn[ 3]:= doubled; 
 AESIntIn[ 4]:= corners; 
 AESIntIn[ 5]:= xc; 
 AESIntIn[ 6]:= yc; 
 AESIntIn[ 7]:= wc; 
 AESIntIn[ 8]:= hc; 
 CallResult:= AESCall(131, 9, 1, 0, 0);
END Xgrf2box;



BEGIN
 AESGlobal.apPtree:= Null;
 WITH AESPB DO
  cbControl:=  ADR (AESControl);
  cbPglobal:=  ADR (AESGlobal);
  cbPintin:=   ADR (AESIntIn);
  cbPintout:=  ADR (AESIntOut);
  cbPadrin:=   ADR (AESAddrIn);
  cbPadrout:=  ADR (AESAddrOut);
 END;
 aespb:= ADR(AESPB);
END MagicAES.