Beschreibung des "single mode" von Mag!X
========================================

Stand: Mag!X 1.12
Andreas Kromke, 4.3.93

Mag!X unterscheidet drei paarweise verschiedene Typen von Applikationen:

a)   Die Applikation #0
b)   Accessories
c)   andere Applikationen (ap_id > 0)

Folgender Aufruf dient unter Mag!X zum Starten von Programmen:

*
* int shel_write(int doex, int isgr, int isover, char *cmd, char *tail)
*

Achtung: MultiTOS arbeitet gnzlich inkompatibel zu bisherigen TOS-
         Versionen. Die neuen Aufrufe werden ber <doex> gesteuert (0 ist
         dabei Programmstart mit automatischer isgr-Erkennung, 1 mit
         manueller isgr-Erkennung usw.), whrend "isover", das hier "iscr"
         heit, die ARGV- bergabe steuert.

Es gibt 5 verschiedene Mglichkeiten, Applikationen von anderen aus zu
starten ("magx.h"). Hier die Parameterwerte fr <isover>:

* #define SHW_IMMED      0                        /* PC-GEM 2.x  */
* #define SHW_CHAIN      1                        /* TOS         */
* #define SHW_DOS        2                        /* PC-GEM 2.x  */
* #define SHW_PARALLEL   100                      /* MAGIX       */
* #define SHW_SINGLE     101                      /* MAGIX       */

Davon werden die Modi 0 und 2 von Mag!X nicht untersttzt. <doex> mu immer
1 sein, sonst werden lediglich vorherige shel_write()-Aufrufe rckgngig
gemacht ( la TOS 1.04).

1.   SHW_PARALLEL
     Eine neue Applikation wird erstellt. Sie erbt alle Standardpfade und
     -dateien von der aktuellen Applikation. Die neue Applikation luft
     parallel zur bisherigen weiter. Man erhlt nur einen Fehlercode, falls
     bereits beim Einrichten Speicherplatzmangel aufgetreten ist. Es gibt
     keine Nachricht bei Beendigung der neuen Applikation (kein
     "death-of-child").
2.   SHW_CHAIN
     Dies ist die Vorgehensweise unter TOS. Das Programm macht den Aufruf,
     und nach Beendigung seiner selbst startet das AES das neue Programm.
     SHW_CHAIN funktioniert nicht bei Accessories, da diese niemals beendet
     werden drfen.
     Das neue Programm erbt die Standardpfade und -dateien, die das
     vorherige Programm zum Zeitpunkt seines Starts hatte. Das sind i.a.
     diejenigen, die wiederum das Programm hatte, das einmal den "Urahn"
     der Applikation mit SHW_PARALLEL gestartet hat. Im Fall der Applikation
     #0 bekommt das neue Programm also die Standardpfade des AES.
     Ist DESKTOP.APP (Shell von GEM 2.2) als Shell angemeldet, fgt Mag!X
     vor den Dateinamen den aktuellen Pfad und Laufwerk ein.
3.   SHW_SINGLE
     Arbeitet wie SHW_CHAIN, mit der Ausnahme, da vor Aufruf des Programms
     alle Applikationen auer Applikation #0 und #1 (SCRENMGR)
     eingefroren werden. Die Programme werden nach Beendigung des Programms
     wieder aufgetaut, wenn dieses nicht seinerseits einen neuen
     shel_write()-Aufruf mit SHW_SINGLE gemacht hat.
     Hinzu kommt, da ab Mag!X 2.00 beim Aufruf von shel_write im Modus
     SHW_SINGLE die aktuellen Pfade des Aufrufers an den Parent und damit an
     das neue Programm bergeben werden. Achtung: Die Pfade des Aufrufers
     sind anschlieend zerstrt, was aber unkritisch ist, da der auf den
     shel_write folgende Aufruf i.a. ein Pterm ist.

Die Schleifen fr SHW_CHAIN und SHW_SINGLE sehen so aus:

Fr Applikation mit ap_id > 0:

     while(doex)
          starte(isgr, cmd, tail);

Fr Applikation #0:

     while(welt_sich_dreht)
          {
          starte_desktop();
          while(doex)
               {
               if   (single_mode && single_mode_noch_nicht_aktiviert)
                    aktiviere_single_mode;
               else taue_ggf_programme_auf;
               starte(isgr, cmd, tail);
               }
          taue_ggf_programme_auf;
          }


Wie starte ich nun ein Programm im "single mode":

a)   Sicherstellen, da ich Applikation #0 bin (d.h. ap_id == 0).
b)   Pfade und Laufwerk fr das neue Programm setzen.
c)   shel_write(TRUE, isgr, SHW_SINGLE, cmd, path);
d)   alle wichtigen Einstellungen in temporre Datei bzw. Shell- Puffer
e)   appl_exit()/v_clsvwk()/Pterm0

Wie starte ich nun ein Programm im "chain mode":

a)   ggf. Pfade und Laufwerk fr das neue Programm setzen und einen
     Aufruf
          shel_write(TRUE, dummy, SHW_SINGLE, dummy2, dummy3);
     machen, um die Pfade fr das neue Programm zu setzen.
     (inkompatibel zu TOS)
b)   shel_write(TRUE, isgr, SHW_CHAIN, cmd, path);
c)   alle wichtigen Einstellungen in temporre Datei bzw. Shell- Puffer
d)   appl_exit()/v_clsvwk()/Pterm0

Nach Beendigung des Programms wird automatisch wieder die Shell geladen.
Beim Aufruf der Shell bekommt man in der Kommandozeile (->shel_read) die
"magische" Sequenz (magx.h):

/* tail for default shell */

typedef struct
     {
     int  dummy;                   /* ein Nullwort               */
     long magic;                   /* 'SHEL', wenn ist Shell     */
     int  isfirst;                 /* erster Aufruf der Shell    */
     long lasterr;                 /* letzter Fehler             */
     int  wasgr;                   /* Programm war Grafikapp.    */
     } SHELTAIL;

Wenn <isfirst> gesetzt ist, ist der Status etwa aus DESKTOP.INF zu lesen,
ist <isfirst> nicht gesetzt, nimmt man die temporre Datei bzw. den
Shell- Puffer.
<lasterr> ist der Rckgabewert des vorher gelaufenen Programms. Wenn dies ein
GEM-Programm war, ist der Fehler bereits per Alertbox angezeigt worden.
Bekannlich ist das Langwort negativ, wenn der Fehler beim Pexec selbst
auftrat, ein Programm-Rckgabewert hat immer Hiword 0.

