home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / MM2_DEV / S / GEM / AESMISC.D < prev    next >
Encoding:
Modula Definition  |  1990-10-09  |  20.0 KB  |  464 lines
  1. DEFINITION MODULE AESMisc;
  2.  
  3.  
  4. (*  Megemax-Modula 2 GEM-Library :  Verschiedene AES Funktionen
  5.  *
  6.  *  Autor: Manuel Chakravarty           Erstellt :  05.11.87
  7.  *
  8.  *  Version   2.2     V#0014
  9.  *)
  10.  
  11.  
  12. FROM SYSTEM     IMPORT BYTE;
  13.  
  14. FROM GrafBase   IMPORT Point, WordBitSet;
  15.  
  16. FROM GEMGlobals IMPORT GemChar;
  17.  
  18.  
  19.                 (*  Application Manager  *)
  20.                 (*  ===================  *)
  21.  
  22. (*      Die folgenden drei Routinen bieten die Möglichkeit mit anderen
  23.  *      Anwendungen zu kommunizieren.
  24.  *      Um die einzelnen Prozesse zu identifizieren weißt das TOS jedem
  25.  *      eine Identifikationsnummer (ID) zu. Die Zuweisung geschieht beim
  26.  *      Start des Programms. Dabei ist zu beachten, daß Moduln, die von
  27.  *      dem Megamax-Modula-Loader gestartet wurden keine ID im Sinne des
  28.  *      TOS besitzen. Vielmehr haben alle Moduln, die von ein und dem-
  29.  *      selben Loader gestartet wurden, die gleiche TOS-ID wie der Loader.
  30.  *      Dies zieht aber keine nenneswerten Einschränkungen nach sich, da
  31.  *      die Organisation des TOS sowieso nur eine Kommunikation zwischen
  32.  *      Accessory's und einem einzelnen Anwendungsprogramm unterstützt.
  33.  *      Die Kommunikation zwischen Parent und Child Prozessen kann in
  34.  *      Modula mit Hilfe entsprechender Modulakonstrukte abgewickelt wer-
  35.  *      den, weshalb man dabei die Unterstützung des TOS gar nicht benötigt.
  36.  *)
  37.  
  38.  
  39. PROCEDURE ReadFromAppl (    id     : CARDINAL;
  40.                         VAR buffer : ARRAY OF BYTE;
  41.                             noBytes: CARDINAL);
  42.  
  43.         (*  Diese Routine erlaubt es den über die 16 Standardbyte hinaus-
  44.          *  gehenden Rest einer Nachricht (Siehe 'AESEvents') zu lesen.
  45.          *
  46.          *  Eingabeparameter
  47.          *  ----------------
  48.          *
  49.          *  'id'        -- Die Identifikationsnummer der Anwendung aus
  50.          *                 Nachrichtenschlange gelesen werden soll.
  51.          *                 In der Regel ist dies wohl die eigne, die
  52.          *                 mit 'GEMEnv.ApplicationID' erfragt werden
  53.          *                 kann.
  54.          *  'noBytes'   -- Anzahl der zu lesenden Bytes. Ist die gleich
  55.          *                 Null, wird stattdessen der HIGH-Wert von
  56.          *                 'buffer' herangezogen.
  57.          *
  58.          *
  59.          *  Ausgabeparameter
  60.          *  ----------------
  61.          *
  62.          *  'buffer'    -- Hier steht die ausgelesene Nachricht.
  63.          *)
  64.         
  65. PROCEDURE WriteToAppl (    id     : CARDINAL;
  66.                        REF message: ARRAY OF BYTE;
  67.                            noBytes: CARDINAL);
  68.  
  69.         (*  Diese Prozedur schickt einer Anwendung eine Nachricht
  70.          *  geschickt.
  71.          *
  72.          *  Eingabeparameter
  73.          *  ----------------
  74.          *
  75.          *  'id'        -- Die Identifikationsnummer der Anwendung
  76.          *  'message'   -- enthält die Nachricht
  77.          *  'noBytes'   -- Länge der Nachricht. Enthält es Null, wird
  78.          *                 HIGH(message) eingesetzt.
  79.          *
  80.          *  Im Regelfall müssen die ersten 16 Byte der Nachricht das
  81.          *  'MessageBuffer'-Format haben, da die Nachricht normalerweise
  82.          *  als Nachrichtenereignis empfangen wird.
  83.          *)
  84.         
  85. PROCEDURE FindApplication (REF fname  : ARRAY OF CHAR;
  86.                            VAR id     : CARDINAL;
  87.                            VAR success: BOOLEAN);
  88.  
  89.         (*  Sucht nach einer bestimmten Anwendung
  90.          *
  91.          *  Eingabeparameter
  92.          *  ----------------
  93.          *
  94.          *  'fname'     -- Name der gesuchten Anwendung (ohne Endung!),
  95.          *                 evtl. nötige Leerzeichen füllt diese Funktion auf.
  96.          *
  97.          *  Ausgabeparameter
  98.          *  ----------------
  99.          *
  100.          *  'success'   --'TRUE' : Anwendung wurde gefunden
  101.          *                'FALSE': ..nicht gefunden
  102.          *  'id'        -- Falls die Suche erfolgreich war, liefert
  103.          *                 es die Identifikationsnummer der Anwendung.
  104.          *
  105.          *  Normalerweise kann damit ein Programm ein Accessory finden,
  106.          *  indem es dessen Dateinamen angibt.
  107.          *  Umgekehrt können Accessories auch die Hauptanwendung finden,
  108.          *  jedoch ist zu beachten, daß evtl. unter der Megamax-Shell
  109.          *  gestartete Programme nicht dem AES bekannt sind, sondern nur
  110.          *  das direkt vom GEM-Desktop gestartete Programm. Das kommt v.A.
  111.          *  vor bei TOS-Versionen vor 1.4. In diesem Fall müßte ein
  112.          *  Accessory nach dem Namen der Shell fragen, oder das Programm
  113.          *  muß gelinkt und dann vom GEM-Desktop gestartet werden.
  114.          *)
  115.  
  116.  
  117.   (*    Die folgenden zwei Routinen funktionieren im aktuellen TOS nicht
  118.    *    einwandfrei, eventuell arbeiten sie mit dem GDOS.
  119.    *)
  120.  
  121. TYPE    RecEvent        = (timerRec, buttonRec, mouseRec, keyboardRec);
  122.  
  123.         RecordedEvent   = RECORD
  124.                             CASE event :RecEvent OF
  125.  
  126.                               timerRec    : time  : LONGCARD|
  127.                               buttonRec   : clicks: CARDINAL;
  128.                                             state : WordBitSet|
  129.                               mouseRec    : loc   : Point|
  130.                               keyboardRec : spcl  : WordBitSet;
  131.                                             ch    : GemChar|
  132.  
  133.                             END;
  134.                           END;
  135.  
  136. PROCEDURE PlayEvents (REF buffer: ARRAY OF RecordedEvent;
  137.                           no    : CARDINAL;
  138.                           scale : CARDINAL);
  139.  
  140.         (*  Bestimmte Ereignisse werden abgespielt, d.h. heißt das
  141.          *  GEM reagiert, als würden diese Ereignisse im Moment
  142.          *  vom Benutzer ausgelöst.
  143.          *
  144.          *  Eingabeparameter
  145.          *  ----------------
  146.          *
  147.          *  'buffer'    -- Hier werden die Ereignisse abgespeichert,
  148.          *                 die abgespielt werden sollen.
  149.          *  'no'        -- Gibt die Anzahl der Ereignisse an, die
  150.          *                 abgespielt werden sollen. Ist sie gleich
  151.          *                 Null wird das gesamte Array abgearbeitet.
  152.          *  'scale'     -- Gibt den Geschwindigkeitsfaktor an, mit dem
  153.          *                 die Ereignisse abgearbeitet werden sollen.
  154.          *                 Dabei ist
  155.          *                 50  -- Halbe Geschwindigkeit
  156.          *                 100 -- Normale Geschwindigkeit
  157.          *                 200 -- Doppelte Geschwindigkeit
  158.          *)
  159.                       
  160. PROCEDURE RecordEvents (VAR buffer  : ARRAY OF RecordedEvent;
  161.                             no      : CARDINAL;
  162.                         VAR recorded: CARDINAL);
  163.  
  164.         (*  Zeichnet Ereignisse auf, die später mit 'PlayEvents' re-
  165.          *  produziert werden können.
  166.          *
  167.          *  Eingabeparameter
  168.          *  ----------------
  169.          *
  170.          *  'no'        -- Anzahl der Ereignisse
  171.          *
  172.          *  Ausgabeparameter
  173.          *  ----------------
  174.          *
  175.          *  'buffer'    -- Hier werden die Ereignisse abgespeichert.
  176.          *  'record'    -- Anzahl der gespeicherten Ereignisse
  177.          *)
  178.  
  179.  
  180.                 (*  File Selector Manager  *)
  181.                 (*  =====================  *)
  182.  
  183.  
  184. PROCEDURE SelectFile (VAR path, name: ARRAY OF CHAR;
  185.                       VAR ok        : BOOLEAN);
  186.  
  187.         (*  Damit kann die bekannte GEM File-Selector-Box erzeugt werden.
  188.          *
  189.          *  Eingabeparameter
  190.          *  ----------------
  191.          *
  192.          *  'path'      -- GEMDOS Pfadnamen oder Leerstring (dann benutzt
  193.          *                 die Routine das Bootlaufwerk)
  194.          *  'name'      -- Filename oder Leerstring
  195.          *
  196.          *  Ausgabeparameter
  197.          *  ----------------
  198.          *
  199.          *  'path'      -- Enthält den GEMDOS Pfadnamen (mit Wildcards)
  200.          *  'name'      -- Enthält den Filenamen
  201.          *  'ok'        -- Liefert 'TRUE',nachdem der Anwender seine
  202.          *                 Auswahl getroffen hat und die Box mit dem
  203.          *                 OK-Knopf beendet wurde.
  204.          *
  205.          *  ACHTUNG: 'path' muß mindestens 64 Zeichen und 'name' mindestens
  206.          *           12 Zeichen fassen können, sonst wird ein Laufzeitfehler
  207.          *           ausgelöst.
  208.          *)
  209.  
  210. PROCEDURE SelectFileExtended (REF label     : ARRAY OF CHAR;
  211.                               VAR path, name: ARRAY OF CHAR;
  212.                               VAR ok        : BOOLEAN);
  213.  
  214.         (*  Damit kann die bekannte GEM File-Selector-Box erzeugt werden.
  215.          *
  216.          *  Eingabeparameter
  217.          *  ----------------
  218.          *
  219.          *  'label'     -- Eine Überschrift, die angibt für welchen Zweck
  220.          *                 eine Datei ausgewählt werden soll.
  221.          *  'path'      -- GEMDOS Pfadnamen oder Leerstring (dann benutzt
  222.          *                 die Routine das Bootlaufwerk)
  223.          *  'name'      -- Filename oder Leerstring
  224.          *
  225.          *  Ausgabeparameter
  226.          *  ----------------
  227.          *
  228.          *  'path'      -- Enthält den GEMDOS Pfadnamen (mit Wildcards)
  229.          *  'name'      -- Enthält den Filenamen
  230.          *  'ok'        -- Liefert 'TRUE',nachdem der Anwender seine
  231.          *                 Auswahl getroffen hat und die Box mit dem
  232.          *                 OK-Knopf beendet wurde.
  233.          *
  234.          *  ACHTUNG: 'path' muß mindestens 64 Zeichen und 'name' mindestens
  235.          *           12 Zeichen fassen können, sonst wird ein Laufzeitfehler
  236.          *           ausgelöst. Außerdem darf 'label' nicht länger als 30
  237.          *           Zeichen sein.
  238.          *           Diese Routine ist erst ab TOS 1.4 implementiert
  239.          *           (kann mit GEMEnv.GEMVersion erfragt werden).
  240.          *)
  241.  
  242.  
  243.  
  244.                 (*  Scrap Manager  *)
  245.                 (*  =============  *)
  246.                 
  247.                 
  248. (*      Der Scrap Manager (Notizenverwalter) verwaltet einen Puffer
  249.  *      (Clipboard, Zwischenablage, Klemmbrett), in dem EIN Objekt
  250.  *      abgelegt und wieder ausgelesen werden kann.
  251.  *
  252.  *      Praktisch sieht das so aus: Eine Anwendung, z.B. eine
  253.  *      Textverarbeitung (1st Word) legt auf Befehl des Benutzers
  254.  *      einen markierten Textblock auf der Disk ab. Dann kann der
  255.  *      Benutzer ein anderes Programm starten oder ein Accessory
  256.  *      aufrufen, wo dann diese Textdatei wiederum zur Weiterver-
  257.  *      arbeitung eingelesen werden kann.
  258.  *
  259.  *      Damit dies funktioniert, müssen sich beide Anwendungen
  260.  *      auf einen Ordner einigen, über den dieses Objekt (der
  261.  *      Textblock) ausgetauscht wird. Zudem müssen beide das Format
  262.  *      des Objekts richtig erkennen (eben, daß es beispielsweise
  263.  *      ein Text ist).
  264.  *
  265.  *      Um das Format zu erkennen, geht man einen einfachen Weg:
  266.  *      Es sind einige Formate festgelegt worden, die dann durch
  267.  *      bestimmte Dateiendungen kenntlich gemacht werden.
  268.  *      So erhalten einfache ASCII-Text-Dateien die Endung "TXT",
  269.  *      Text-Dateien im First-Word-Format die Endung "1ST".
  270.  *      Es gibt noch weitere Festlegungen, z.B. für Grafiken.
  271.  *
  272.  *      Die Anwendung, die die Datei erzeugt, legt diese nun in
  273.  *      möglichst vielen sinnvollen verschiedenen Formaten ab.
  274.  *      1st Word beispielsweise legt sie im 1st-Word-Format und
  275.  *      im einfacheren ASCII-Format (ohne Formatierungs- und Text-
  276.  *      Attribute) ab. Die Dateinamen werden immer aus dem festgelegten
  277.  *      Ordner, 'SCRAP' und der zugehörigen Endung zusammengesetzt,
  278.  *      also im Beispiel "SCRAP.1ST" und "SCRAP.TXT".
  279.  *      Die lesende Anwendung sucht dann ihrerseits ihre möglichen,
  280.  *      sinnvollen Formate. Ist es z.B. nur ein einfacher Texteditor,
  281.  *      wird er ggf. nicht das 1st-Word-Format kennen, aber das
  282.  *      einfache Textformat sollte er zumindest verstehen - er sucht
  283.  *      also im festgelegten Ordner nach der Datei "SCRAP.TXT" und
  284.  *      lädt sie.
  285.  *
  286.  *      Für die Anwendung, die die Dateien schreibt, ist zu beachten,
  287.  *      daß sie vor dem Ablegen das evtl. vorher im Ordner liegende
  288.  *      Objekt löscht - also müssen alle Dateien, die auf "SCRAP"
  289.  *      beginnen, gelöscht werden. Dies ist beim MM2-System sehr
  290.  *      einfach mit der Funktion EasyGEM1.ClearScrap zu erreichen.
  291.  *
  292.  *      Der Ordnername nun soll eigentlich vom Start des Rechners an
  293.  *      festgelegt sein und kann dann mit der Funktion "ReadScrapDir"
  294.  *      (s.u.) gelesen werden.
  295.  *      Allerdings ist der Name leider nicht automatisch zu Beginn
  296.  *      festgelegt. Abhilfe schafft hier ein Hilfsprogramm, z.B. ein
  297.  *      Accessory, das ggf. einen Ordner dazu anlegt und dann mittels
  298.  *      "WriteScrapDir" diesen Ordnernamen für alle weiteren Anwendungen
  299.  *      setzt.
  300.  *      Nun muß aber jede Anwendung damit rechnen, daß dieser Scrap-
  301.  *      Pfad nicht gesetzt wurde. Sie darf dann ggf. selbst einen
  302.  *      Ordner anlegen und diesen zum Scrap-Dir machen.
  303.  *      Dies alles erledigt die Funktion 'MakeScrapName' im Modul
  304.  *      'EasyGem1' automatisch!
  305.  *)
  306.  
  307. PROCEDURE ReadScrapDir (VAR dir: ARRAY OF CHAR);
  308.  
  309.         (*  Ermittelt Namen des aktuellen Scrap-Pfades.
  310.          *
  311.          *  'dir'       -- Der Scrap-Pfadname wird hier abge-
  312.          *                 speichert. Dieser Name ist nicht
  313.          *                 unbedingt mit einem '\' abgeschlossen,
  314.          *                 dieser ist dann ggf. selbst anzufügen
  315.          *                 (z.B. mit 'Directory.ValidatePath')!
  316.          *
  317.          *  Siehe auch 'EasyGEM1.MakeScrapName'!
  318.          *)
  319.  
  320. PROCEDURE WriteScrapDir (REF dir: ARRAY OF CHAR);
  321.  
  322.         (*  Setzt den Namen des aktuellem Scrap-Pfades.
  323.          *
  324.          *  'dir'       -- Wird zum neuen Scrap-Pfadnamen
  325.          *                 Bsp: WriteScrapDir ("C:\CLIPBRD\")
  326.          *)
  327.  
  328.  
  329.                 (*  Shell Manager  *)
  330.                 (*  =============  *)
  331.  
  332.  
  333. PROCEDURE ShellRead (VAR cmd, tail: ARRAY OF CHAR);
  334.  
  335.         (*  Diese Routine erfragt die Kommandozeile und das Kommando,
  336.          *  durch welches das aktuelle Programm gestartet wurde.
  337.          *
  338.          *  Ausgabeparameter
  339.          *  ----------------
  340.          *
  341.          *  'cmd'       -- Enthält das Kommando (Programmnamen)
  342.          *  'tail'      -- Enthält die Kommandozeile (das Längenbyte ist
  343.          *                   bereits ausgewertet)
  344.          *
  345.          *  Vorsicht: Bei den TOS-Versionen älter als 1.4 (also beim
  346.          *    altem ROM-TOS und Blitter-TOS) wird der Programname
  347.          *    nur solange korrekt zurückgeliefert, bis ein 'ShellFind'-
  348.          *    oder 'LoadResource'-Aufruf getätigt wird (danach wird
  349.          *    fälschlicherweise der Name der Resource geliefert)!
  350.          *
  351.          *)
  352.  
  353.  
  354. TYPE    ProgramType     = (textPrgm, graphicPrgm);
  355.  
  356. PROCEDURE ShellWrite (    start    : BOOLEAN;
  357.                           io       : ProgramType;
  358.                       REF cmd, tail: ARRAY OF CHAR);
  359.  
  360.         (*  Damit ist es möglich, andere Programme von einer laufenden
  361.          *  Anwendung aus zu starten.
  362.          *
  363.          *  Eingabeparameter
  364.          *  ----------------
  365.          *
  366.          *  'cmd'         -- Bestimmt das Kommando für den zu star-
  367.          *                   tenden Prozeß (Programmname, am Besten mit
  368.          *                   vollst. Pfad -> 'Directory.MakeFullPath')
  369.          *  'tail'        -- Bestimmt die Kommandozeile (Argumentzeile)
  370.          *
  371.          *  'io' kann folgende Werte annehmen:
  372.          *
  373.          *    'textPrgm'    -- Zu startendes Programm läuft im Textmodus
  374.          *    'graphicPrgm' -- Zu startendes Programm läuft im Grafikmodus
  375.          *
  376.          *  'start' kann folgende Werte annehmen:
  377.          *
  378.          *    'TRUE'        -- Die in 'cmd' angegebene Anwendung wird
  379.          *                     nach Terminierung der Laufenden vom GEM-
  380.          *                     Desktop gestartet, sofern dahin zurückgekehrt
  381.          *                     wird.
  382.          *    'FALSE'       -- TOS 1.0 & 1.2: wie 'TRUE'; ab TOS 1.4:
  383.          *                     Es wird keine neue Anwendung gestartet.
  384.          *                     Bei diesem Modus sollte 'io' = 'graphicPrgm'
  385.          *                     (bzw. der Typ des endenden Programms), weil
  386.          *                     sonst beim Verlassen das Desktop hängen bleiben
  387.          *                     kann.
  388.          *
  389.          *  Achtung:           Erst ab TOS 1.4 ist es hiermit möglich,
  390.          *  ========           einen vorher erfolgten ShellWrite-Aufruf wieder
  391.          *                     rückgängig zu machen, sodaß bei Terminierung
  392.          *                     des laufenden Programms keine neue Anwendung
  393.          *                     gestartet sondern zum Desktop zurückgekehrt
  394.          *                     wird. Bei den alten TOS-Versionen dagegen
  395.          *                     hat dies keinen Effekt - wenn erstmal ein
  396.          *                     ShellWrite-Aufruf erfolgte, versucht das
  397.          *                     GEM-Desktop immer, das beim letzten ShellWrite-
  398.          *                     Aufruf in 'cmd' angegebene Programm zu starten,
  399.          *                     wenn das aktuelle Programm abgelaufen ist.
  400.          *                     Deshalb sollte dann zumindest ein Programm
  401.          *                     bei 'start = FALSE' angegeben werden, das
  402.          *                     praktisch nichts tut, als sich starten zu
  403.          *                     lassen und gleich wieder zu terminieren. Ist
  404.          *                     auch das nicht vorsehbar, sollte ein Leername
  405.          *                     bei 'cmd' angegeben werden, damit nicht irgend-
  406.          *                     ein anderes Programm unerwünscht aufgerufen
  407.          *                     wird. Allerdings ist dann mit einer Fehler-
  408.          *                     meldung des GEM-Desktop zu rechnen.
  409.          *)
  410.  
  411. PROCEDURE ShellGet (VAR buffer: ARRAY OF BYTE; no: CARDINAL);
  412.  
  413.         (*  Liest Zeichen aus dem Environment-Speicher des GEM.
  414.          *
  415.          *  Der Puffer 'buffer' sollte mind. 4192 Bytes groß sein!
  416.          *
  417.          *  'no'        -- Anzahl der zu Übertragenden Zeichen
  418.          *                 Falls 'no = 0' wird das gesammte Array
  419.          *                 gefüllt.
  420.          *)
  421.  
  422. PROCEDURE ShellPut (REF buffer: ARRAY OF BYTE; no: CARDINAL);
  423.  
  424.         (*  Schreibt Zeichen in den Environment-Speicher des GEM.
  425.          *
  426.          *  'no'        -- Gibt an, wieviele Zeichen übertragen
  427.          *                 werden sollen.Bei einem Wert von Null
  428.          *                 wird das gesamte Array gefüllt.
  429.          *
  430.          *  Die Anzahl der zu schreibenden Bytes darf bei TOS 1.0
  431.          *  und TOS 1.2 (Blitter-TOS) 1024, bei TOS 1.4 (Rainbow-TOS)
  432.          *  4192 Byte nicht überschreiten! (Ggf. die Version des
  433.          *  GEM mittels GEMEnv.GEMVersion abfragen).
  434.          *)
  435.  
  436. PROCEDURE ShellFind (VAR name: ARRAY OF CHAR);
  437.  
  438.         (*  Das AES sucht die Datei 'name'.
  439.          *
  440.          *  Bei TOS 1.0 und 1.2 wird dazu im aktuellen Inhaltsverzeichnis
  441.          *  und dann im Wurzelverzeichnis des Boot-Laufwerks gesucht
  442.          *  (genaugenommen in den Verzeichnissen, die im Environment-Speicher
  443.          *  unter "PATH" eingetragen sind - dieser ist bisher aber praktisch
  444.          *  nicht veränderbar).
  445.          *  Ab TOS 1.4 wird zusätzlich auf dem Pfad gesucht, von dem die
  446.          *  laufende Anwendung gestartet wurde (also dem Verzeichnis, das
  447.          *  in 'cmd' aus 'ShellRead' ermittelbar ist).
  448.          *
  449.          *  'name'      -- Enthält den Namen der zu suchenden Datei.
  450.          *                 Ist sie vorhanden, wird der komplette Name
  451.          *                 incl. Pfad zurückgeliefert. Wird es nicht
  452.          *                 gefunden, so ist 'GemError() = TRUE'.
  453.          *)
  454.  
  455. PROCEDURE ShellEnvironment (REF parm: ARRAY OF CHAR; VAR value: ARRAY OF CHAR);
  456.  
  457.         (*  In den Zeichenketten der TOS-Umgebung wird nach 'parm' gesucht.
  458.          *  Verläuft die Suche erfolgreich, so enthält 'value' die Zeichen,
  459.          *  die in der Umgebungszeichenkette auf 'parm' folgen.
  460.          *)
  461.  
  462.  
  463. END AESMisc.
  464.