home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / util / rsys-1.3.lha / RSys-1.3 / src / RSysAction.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-07  |  21.3 KB  |  729 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysAction.c
  6. *
  7. * Inhalt:
  8. *    void BuildActionList(void);
  9. *    int StartAction(int ftype, char *file, short last);
  10. *
  11. * Bemerkungen:
  12. *    Actioning-Routinen von RSys. Wird ein Icon auf das AppIcon von
  13. *    RSys gezogen, werden entsprechend des Dateityps Aktionen
  14. *    gestartet.
  15. *
  16. * Erstellungsdatum:
  17. *    07-Jan-93    Rolf Böhme
  18. *
  19. * Änderungen:
  20. *    07-Jan-93    Rolf Böhme    Erstellung
  21. *
  22. ***************************************************************************
  23. */
  24.  
  25. #include "RSysDebug.h"
  26. #include "RSysFunc.h"
  27.  
  28.    /*
  29.     * Der Zeiger auf alle Actions, die aus der Datei
  30.     * sys.act eingelesen werden.
  31.     */
  32. struct _acts *Actions;
  33.  
  34.    /*
  35.     * Die Liste aller gelesenen Aktionen.
  36.     */
  37. struct List ActionList,
  38.       DisplayList;
  39.    /*
  40.     * Ein globaler Zähler für die eingelesenen Aktionen.
  41.     */
  42. int   counter;
  43.    /*
  44.     * Liste aller Aktionen zu einem Dateityp.
  45.     */
  46. struct List DL;
  47.  
  48.    /*
  49.     * Die Intuition-Objekte für den Aufbau des
  50.     * "Auswahl-Fensters der Aktionen".
  51.     */
  52. static struct Window *ActionWnd = NULL;
  53. static struct Gadget *ActionGList = NULL;
  54. static struct Gadget *ActionGadgets[4];
  55. static UWORD ActionLeft = 211;
  56. static UWORD ActionTop = 43;
  57. static UWORD ActionWidth = 149;
  58. static UWORD ActionHeight;
  59. static UBYTE ActionWdt[14] = (UBYTE *) "Action";
  60.  
  61.    /*
  62.     * Die Funktion OpenActionWindow() öffnet ein Fenster
  63.     * mit einem ListView und zwei Gadgets. Im ListView
  64.     * werden die Aktionen zu einem erkannten Dateitypen
  65.     * angezeigt. Werden mehrere Dateien behandelt, so
  66.     * erscheint ein weiteres Gadget, mit dem man zur
  67.     * nächsten Datei wechseln kann.
  68.     */
  69. static long
  70. OpenActionWindow(struct List *AL, BOOL last)
  71. {
  72.    struct NewGadget ng;
  73.    struct Gadget *g;
  74.    UWORD wleft = ActionLeft,
  75.          wtop = ActionTop,
  76.          ww,
  77.          wh;
  78.    int gl[] = {GD_FileTypeTGad,GD_ActionLV};
  79.  
  80.       /*
  81.        * Die Höhe des Fensters wird entsprechend der
  82.        * Gadgetanzahl bestimmt. Ist last TRUE, gibt es nur
  83.        * drei Gadgets, sonst vier.
  84.        */
  85.    ActionHeight = (last ? 92 : 108);
  86.  
  87.       /*
  88.        * Der Font wird für das neue Fenster festgelegt. Ist
  89.        * der Font zu groß, wird automatisch topaz 8
  90.        * genommen.
  91.        */
  92.    ComputeFont(Scr,ActionWidth, ActionHeight);
  93.  
  94.       /*
  95.        * Die Höhe und Weite des Fensters wird fontsensitiv
  96.        * bestimmt.
  97.        */
  98.    ww = compute((UWORD) 0, FontX, (int)ActionWidth);
  99.    wh = compute((UWORD) 0, FontY, (int)ActionHeight);
  100.  
  101.    if ((wleft + ww + OffX + Scr->WBorRight) > Scr->Width)
  102.       wleft = Scr->Width - ww;
  103.    if ((wtop + wh + OffY + Scr->WBorBottom) > Scr->Height)
  104.       wtop = Scr->Height - wh;
  105.  
  106.    ww = compute((UWORD) (OffX + Scr->WBorRight), FontX, (int)ActionWidth);
  107.    wh = compute((UWORD) (OffY + Scr->WBorBottom), FontY, (int)ActionHeight);
  108.  
  109.       /*
  110.        * Das Fenster wird zentriert auf den aktiven Screen
  111.        * gebracht.
  112.        */
  113.    CenterWindow(Scr, &wtop, &wleft, ww, wh);
  114.  
  115.       /*
  116.        * Der Gadtools-Kontext dr Benutzeroberfläche wird
  117.        * erzeugt.
  118.        */
  119.    if (NOT(g = CreateContext(&ActionGList)))
  120.       return (1L);
  121.  
  122.       /*
  123.        * Der Reihe nach werden alle Gadgets des Fensters
  124.        * erzeugt und in den Kontext eingebunden. Dabei
  125.        * werden pro Gadget nur die Werte verändert, die
  126.        * sich gegenüber dem vorhergehenden gändert haben.
  127.        */
  128.    ng.ng_LeftEdge = compute(OffX, FontX, 4);
  129.    ng.ng_TopEdge = compute(OffY, FontY, 1);
  130.    ng.ng_Width = compute((UWORD) 0, FontX, 141);
  131.    ng.ng_Height = compute((UWORD) 0, FontY, 15);
  132.    ng.ng_GadgetText = NULL;
  133.    ng.ng_TextAttr = Font;
  134.    ng.ng_GadgetID = GD_FileTypeTGad;
  135.    ng.ng_Flags = 0;
  136.    ng.ng_VisualInfo = VisualInfo;
  137.  
  138.    g = CreateGadget(TEXT_KIND, g, &ng, GTTX_Text, NULL, GTTX_Border, TRUE, TAG_DONE);
  139.  
  140.    ActionGadgets[0] = g;
  141.  
  142.    ng.ng_TopEdge = compute(OffY, FontY, 17);
  143.    ng.ng_Height = compute((UWORD) 0, FontY, 60);
  144.    ng.ng_GadgetID = GD_ActionLV;
  145.  
  146.    g = CreateGadget(LISTVIEW_KIND, g, &ng, GTLV_Labels, AL, TAG_DONE);
  147.  
  148.    ActionGadgets[1] = g;
  149.  
  150.    ng.ng_TopEdge = compute(OffY, FontY, 78);
  151.    ng.ng_Height = compute((UWORD) 0, FontY, 13);
  152.    ng.ng_GadgetText = (UBYTE *) "_Info";
  153.    ng.ng_GadgetID = GD_FInfo;
  154.    ng.ng_Flags = PLACETEXT_IN;
  155.  
  156.    g = CreateGadget(BUTTON_KIND, g, &ng, GT_Underscore, '_', TAG_DONE);
  157.  
  158.    ActionGadgets[2] = g;
  159.  
  160.       /*
  161.        * Falls es sich nicht um die letzte Datei handelt,
  162.        * wird ein weiteres Gadget eingebunden.
  163.        */
  164.    if (NOT(last))
  165.    {
  166.       ng.ng_TopEdge = compute(OffY, FontY, 92);
  167.       ng.ng_GadgetText = (UBYTE *) "Next Entry";
  168.       ng.ng_GadgetID = GD_NextEntryGad;
  169.  
  170.       g = CreateGadget(BUTTON_KIND, g, &ng, TAG_DONE);
  171.  
  172.       ActionGadgets[3] = g;
  173.    }
  174.  
  175.    if (NOT g)
  176.       return (2L);
  177.  
  178.       /*
  179.        * Das Fenster wird mit den entsprechenden
  180.        * Attributen versehen geöffnet.
  181.        */
  182.    if (NOT(ActionWnd = OpenWindowTags(NULL,
  183.                                       WA_Left, wleft,
  184.                                       WA_Top, wtop,
  185.                                       WA_Width, ww,
  186.                                       WA_Height, wh,
  187.                                       WA_IDCMP, TEXTIDCMP | LISTVIEWIDCMP |
  188.                                       IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE |
  189.                                       IDCMP_CLOSEWINDOW |
  190.                                       IDCMP_REFRESHWINDOW | VANILLAKEY,
  191.                                       WA_Flags, WFLG_DRAGBAR | WFLG_DEPTHGADGET |
  192.                                       WFLG_CLOSEGADGET | WFLG_SMART_REFRESH |
  193.                                       WFLG_RMBTRAP | WFLG_ACTIVATE,
  194.                                       WA_Gadgets, ActionGList,
  195.                                       WA_Title, ActionWdt,
  196.                                       WA_PubScreenName, (UBYTE *)"Workbench",
  197.                                       TAG_DONE)))
  198.       return (4L);
  199.  
  200.    RefreshRastPort(ActionWnd,ActionGadgets,gl, 2);
  201.  
  202.    if(Flags.autofront)
  203.    {
  204.       WindowToFront(ActionWnd);
  205.       ActivateWindow(ActionWnd);
  206.    }
  207.  
  208.  
  209.    return (NULL);
  210. }
  211.  
  212.    /*
  213.     * Diese Procedure erzeugt ein Listenelement in der
  214.     * Aktionsliste. Dazu wird eine eingelesene Zeile mit
  215.     * der C-Library-Funktion strtok() in einzelne Teile
  216.     * zerlegt, die durch ein '#' getrennt sind.
  217.     */
  218. static void
  219. BuildActionEntry(UBYTE * line, struct _acts *Act)
  220. {
  221.       /*
  222.        * Die Token für den weiteren Duchlauf
  223.        * initialisieren.
  224.        */
  225.    char *token = strtok((char *)line, ACTION_TOKEN);
  226.  
  227.       /*
  228.        * Der Listenknoten wird gemäß der C=-Richtlinien
  229.        * initialisiert.
  230.        */
  231.    Act->act_Node.ln_Pri = 0;
  232.    Act->act_Node.ln_Type = NT_USER;
  233.    Act->act_Node.ln_Name = Act->act_name;
  234.  
  235.       /*
  236.        * Das  erste  Token  enthält  die Dateitypnummer des
  237.        * entsprechenden Eintrags, die auch der intern
  238.        * verwendeten Nummer entspricht.
  239.        */
  240.    Act->act_filetype = atoi(token);
  241.  
  242.       /*
  243.        * Dieses Token enthält den Dateityp als String, der
  244.        * in dem Textgadget über dem ListView erscheint.
  245.        */
  246.    token = strtok(STRINGEND, ACTION_TOKEN);
  247.    strcpy(Act->act_listviewheader, token);
  248.  
  249.       /*
  250.        * Dieser Token enthält die Aktionsbezeichnung, die
  251.        * in dem ListView angezeigt wird.
  252.        */
  253.    token = strtok(STRINGEND, ACTION_TOKEN);
  254.    strcpy(Act->act_name, token);
  255.  
  256.       /*
  257.        * Dieser Token enthält die Aktion, die nach der
  258.        * Anwahl des entsprechenden ListView-Eintrags
  259.        * ausgeführt wird.
  260.        */
  261.    token = strtok(STRINGEND, ACTION_TOKEN);
  262.    strcpy(Act->act_command, token);
  263.  
  264.       /*
  265.        * Das Prioritätsfeld des Knotens in der
  266.        * Actions-Struktur mißbrauchen wir als Flag, das
  267.        * festlegt, ob nach dieser Aktion das Action-Fenster
  268.        * geschlossen werden soll oder nicht.
  269.        */
  270.    token = strtok(STRINGEND, ACTION_TOKEN);
  271.    Act->act_Node.ln_Pri = (*token == 'W') ? 1 : 0;
  272.  
  273.    return;
  274. }
  275.  
  276.    /*
  277.     * Die Funktion BuildActionList() holt aus der
  278.     * Environmentvariablen SYSACTION die
  279.     * Bezeichnung der Datei, die die Aktionen für die
  280.     * einzelnen Dateitypen enthält und baut aus den
  281.     * Inhalten dieser Datei eine Liste auf.
  282.     */
  283. void
  284. BuildActionList(void)
  285. {
  286.    BPTR  actfile;
  287.    UBYTE actfilename[MAXFULLNAME+1];
  288.    int   i = 0;
  289.    UBYTE line[MAXLINESIZE+1],
  290.         *buf;
  291.  
  292.    DPOS;
  293.  
  294.       /*
  295.        * Falls bereits zuvor die Datei gelesen und eine
  296.        * Liste aufgebaut wurde, wird der Speicher jetzt
  297.        * freigegeben und der Zeiger initialisiert.
  298.        */
  299.    MyFreeVec(Actions);
  300.    Actions = NULL;
  301.  
  302.       /*
  303.        * Die Environmentvariable SYSACTION wird gelesen und
  304.        * die Datei geöffnet, falls die Variable korrekt
  305.        * ausgelesen werden konnte.
  306.        */
  307.    if (GetVar((UBYTE *) "RSYSACTION", actfilename, MAXFULLNAME, GVF_GLOBAL_ONLY) > 0)
  308.       if (actfile = Open(actfilename, MODE_OLDFILE))
  309.       {
  310.             /*
  311.              * Der erste Eintrag in der Datei enthält die Anzahl
  312.              * der eingetragenen Aktionen.
  313.              */
  314.          FGets(actfile, line, MAXLINESIZE);
  315.          counter = atoi((char *)line);
  316.  
  317.             /*
  318.              * Falls der Eintrag keine gültige Zahl war, lieferte
  319.              * atoi() den Wert 0 zurück.  In diesem Falle wird
  320.              * das Unterprogramm mit dem Schließen der Datei und
  321.              * einer Fehlermeldung abgebrochen.
  322.              */
  323.          if (!counter)
  324.          {
  325.             Close(actfile);
  326.             ErrorHandle(FILE_ERR, WRONG_FAIL, NO_KILL);
  327.             return;
  328.          }
  329.  
  330.             /*
  331.              * Für die Liste wird entsprechend der Anzahl der
  332.              * Einträge Speicherplatz besorgt.
  333.              */
  334.          Actions = MyAllocVec(counter * sizeof(struct _acts),
  335.                               MEMF_ANY | MEMF_CLEAR, NO_KILL);
  336.  
  337.          if (Actions)
  338.          {
  339.                /*
  340.                 * Die Action-Liste wird aktualisiert.
  341.                 */
  342.             NewList(&ActionList);
  343.  
  344.                /*
  345.                 * Die erste Zeile wird gelesen.
  346.                 */
  347.             buf = FGets(actfile, line, MAXLINESIZE);
  348.  
  349.                /*
  350.                 * In dieser Zeile werden alle Aktionen eingelesen
  351.                 * und die Liste aufgebaut.
  352.                 */
  353.             for (i = 0; (i < counter) && buf; i++)
  354.             {
  355.                BuildActionEntry(line, &Actions[i]);
  356.  
  357.                AddTail(&ActionList, &Actions[i].act_Node);
  358.                buf = FGets(actfile, line, MAXLINESIZE);
  359.             }
  360.  
  361.                /*
  362.                 * Falls ein Fehler beim Lesen auftrat oder weniger
  363.                 * Zeilen in der Datei waren, als counter angibt,
  364.                 * wird eine Fehlermeldung erzeugt.
  365.                 */
  366.             if (!buf && IoErr())
  367.                ErrorHandle(FILE_ERR, READ_FAIL, NO_KILL);
  368.          }
  369.  
  370.             /*
  371.              * Die Datei wird nach dem Auslesen geschlossen.
  372.              */
  373.          Close(actfile);
  374.  
  375.          return;
  376.       }
  377.       else
  378.          ErrorHandle(FILE_ERR, FIND_FAIL, NO_KILL);
  379.    else
  380.       ErrorHandle(ENV_ERR, FIND_FAIL, NO_KILL);
  381.  
  382.    return;
  383. }
  384.  
  385.    /*
  386.     * Die Prozedur ShowInfo() zeigt entsprechend des
  387.     * Dateityps Directory, Device oder File eine Info
  388.     * in Form eines Systemrequesters.
  389.     */
  390. static void
  391. ShowInfo(char *file)
  392. {
  393.    APTR  req;
  394.    struct objectid obj;
  395.  
  396.       /*
  397.        * Das Actionwindow wird mit einem unsichtbaren
  398.        * Requester gegen Eingaben geschützt, während die
  399.        * Anzeige aktiv ist.
  400.        */
  401.    req = LockWindow(ActionWnd);
  402.  
  403.       /*
  404.        * Entsprechend des letzten Zeichens der Datei wird
  405.        * entschieden, ob es sich um ein Device, ein
  406.        * Verzeichnis oder eine Datei handelt.
  407.        */
  408.    switch (file[strlen(file) - 1])
  409.    {
  410.          /*
  411.           * Die Datei ist eine Disk. Auf Wunsch wird eine
  412.           * Verzeichnisstruktur dieser Disk gezeigt.
  413.           */
  414.       case ':':
  415.          if (NOT(DisplayDiskInfo(file, TRUE)))
  416.          {
  417.             strcpy(obj.fullname, file);
  418.             PrintTree(&obj);
  419.          }
  420.          break;
  421.  
  422.          /*
  423.           * Die Datei ist ein Verzeichnis.  Auf Wunsch wird
  424.           * eine Verzeichnisstruktur diese Verzeichnisses
  425.           * gezeigt.
  426.           */
  427.       case '/':
  428.          DisplayDirectoryInfo(file);
  429.          break;
  430.  
  431.          /*
  432.           * Ist jedem anderen Fall wird eine allgemeine
  433.           * Fileinfo angezeigt. Die Routine PrintHunkStruct()
  434.           * entscheidet außerdem, ob es ein Executable ist und
  435.           * bietet entsprechend die Möglichkeit an, ein
  436.           * Hunklisting zu erzeugen.
  437.           */
  438.       default:
  439.          if (NOT(DisplayFileInfo(file)))
  440.             PrintHunkStruct(file);
  441.          break;
  442.    }
  443.  
  444.       /*
  445.        * Das Actionwindow wird wieder freigegeben.
  446.        */
  447.    UnlockWindow(req);
  448.  
  449.    return;
  450. }
  451.  
  452.    /*
  453.     * Die Funktion StartAction() baut eine Teilliste für
  454.     * den entsprechenden Dateitypen auf und präsentiert
  455.     * ein Fenster mit drei oder vier Gadgets. Wenn last
  456.     * TRUE ist, handelt es sich um die letzte oder nur
  457.     * eine Datei. Andernfalls wurden mehrere Gadgets
  458.     * über das AppIcon von RSys gezogen und es erscheint
  459.     * ein viertes Gadget "Next".
  460.     */
  461. int
  462. StartAction(int ftype, char *file, BOOL last)
  463. {
  464.    register struct IntuiMessage *message;
  465.    ULONG class,
  466.          code;
  467.    APTR  object;
  468.    ULONG mask;
  469.    struct Node *node = NULL;
  470.    struct _acts *act = NULL;
  471.    int   GID,
  472.          cnt = 0,
  473.          j,
  474.          ret = TRUE,
  475.          new;
  476.    UBYTE *basename = FilePart((UBYTE *) file);
  477.    UBYTE *dirname = PathPart((UBYTE *) file);
  478.  
  479.    DPOS;
  480.  
  481.    Flags.quit_action_flag = 0;
  482.       /*
  483.        * Initialisierung der Anzeigeliste.
  484.        */
  485.    NewList(&DL);
  486.  
  487.       /*
  488.        * Die Actions, die dem Filetypen entsprechen, werden
  489.        * gezählt.
  490.        */
  491.    for (j = 0; j < counter; j++)
  492.       if (Actions[j].act_filetype == ftype)
  493.          cnt++;
  494.  
  495.       /*
  496.        * Falls Actionen gefunden wurden...
  497.        */
  498.    if(cnt)
  499.    {
  500.          /*
  501.           * ...wird entsprechend Speicher besorgt.
  502.           */
  503.       act = MyAllocVec((cnt+1) * sizeof(struct _acts),
  504.                        MEMF_CLEAR | MEMF_ANY, NO_KILL);
  505.  
  506.          /*
  507.           * Das Unterprogramm wird verlassen, falls nicht
  508.           * genügend Speicher reserviert werden konnte.
  509.           */
  510.       if (NOT(act))
  511.          return (FALSE);
  512.  
  513.          /*
  514.           * Der Zähler für die Teilliste wird initialisiert.
  515.           */
  516.       new = 0;
  517.  
  518.          /*
  519.           * Die neue Displayliste wird aufgebaut und die
  520.           * Einträge gezählt.
  521.           */
  522.       for (j = 0; (j < counter) && (new < cnt); j++)
  523.          if (Actions[j].act_filetype == ftype)
  524.          {
  525.             CopyMem((APTR) & Actions[j], (APTR) & act[new], sizeof(struct _acts));
  526.             AddTail(&DL, &act[new++].act_Node);
  527.          }
  528.    }
  529.  
  530.          /*
  531.        * Falls die Datei kein Verzeichnis ist, wird für den
  532.        * Windowtitle der Basisname der Datei gebildet, also
  533.        * Filename ohne Pfad.
  534.        */
  535.    if (ftype != TYPE_DIR)
  536.       strncpy((char *)ActionWdt, (char *)basename, 13);
  537.    else
  538.    {
  539.          /*
  540.           * Falls es ein Verzeichnis ist, werden maximal 13
  541.           * Zeichen des Strings für die Titelzeile kopiert.
  542.           */
  543.       int   dirlen = MIN(13, ((char *)dirname - (char *)file));
  544.  
  545.       strncpy((char *)ActionWdt, (char *)file, dirlen);
  546.  
  547.       ActionWdt[dirlen] = STRINGEND;
  548.    }
  549.  
  550.       /*
  551.        * Die Bildschirmattribute werden bestimmt und das
  552.        * Actionwindow geöffnet.
  553.        */
  554.    if (!SetupScreen() && !OpenActionWindow(&DL, last))
  555.    {
  556.          /*
  557.           * Der Dateityp wird in das Textgadget eingetragen.
  558.           */
  559.       GT_SetGadgetAttrs(ActionGadgets[GD_FileTypeTGad], ActionWnd,
  560.                         NULL,
  561.                         GTTX_Text, mess[ftype],
  562.                         TAG_DONE);
  563.  
  564.       do
  565.       {
  566.             /*
  567.              * Es wird auf ein ^C oder ein Signal vom
  568.              * Actionwindow gewartet.
  569.              */
  570.          mask = Wait(SIGBREAKF_CTRL_C |
  571.                      (1L << ActionWnd->UserPort->mp_SigBit));
  572.  
  573.             /*
  574.              * Falls ein ^C erkannt wurde, wird das Actioning
  575.              * beendet.
  576.              */
  577.          if (mask & SIGBREAKF_CTRL_C)
  578.             Flags.quit_action_flag = 1;
  579.  
  580.             /*
  581.              * Es ist eine Nachricht am Userport des
  582.              * Actionwindows eingetroffen.
  583.              */
  584.          if (mask & (1L << ActionWnd->UserPort->mp_SigBit))
  585.             while ((message = (struct IntuiMessage *)
  586.                     GT_GetIMsg(ActionWnd->UserPort)) != NULL)
  587.             {
  588.                   /*
  589.                    * Die notwendigen Daten werden aus der
  590.                    * Message-Struktur kopiert.
  591.                    */
  592.                object = message->IAddress;
  593.                class = message->Class;
  594.                code = message->Code;
  595.  
  596.                   /*
  597.                    * Damit Intuition nicht wartet, wird die Nachricht
  598.                    * sofort beantwortet.
  599.                    */
  600.                GT_ReplyIMsg(message);
  601.  
  602.                switch(class)
  603.                {
  604.                      /*
  605.                       * Falls ein angeklicktes Gadget losgelassen wurde,
  606.                       * wird entsprechend der GadgetID eine Aktion
  607.                       * gestartet.
  608.                       */
  609.                   case IDCMP_GADGETUP:
  610.                         GID = ((struct Gadget *)object)->GadgetID;
  611.                         switch(GID)
  612.                         {
  613.                            /*
  614.                             * Falls es sich nicht um die letzte Datei handelt,
  615.                             * wird das Unterprogramm beendet, wenn das
  616.                             * "Next"-Gadget geklickt wird.
  617.                             */
  618.                         case GD_NextEntryGad:
  619.                            if (NOT(last))
  620.                            {
  621.                               Flags.quit_action_flag = 1;
  622.                               node = NULL;
  623.                            }
  624.                            break;
  625.  
  626.                            /*
  627.                             * Falls das "Info"-Gadget geklickt wurde, wird eine
  628.                             * Info in Form eines Systemrequesters angezeigt.
  629.                             * Falls es zu diesem Dateityp keine Aktionen gibt,
  630.                             * die Liste DL also leer ist, wird das Unterprogramm
  631.                             * beendet. Zuvor wird dann der MessagePort des
  632.                             * ActionWindows geleert.
  633.                             */
  634.                         case GD_FInfo:
  635.                            ShowInfo(file);
  636.                            node = NULL;
  637.  
  638.                            if(IsListEmpty(&DL))
  639.                            {
  640.                               ClearIntuiMsgPort(ActionWnd);
  641.                               Flags.quit_action_flag = 1;
  642.                            }
  643.                            break;
  644.  
  645.                            /*
  646.                             * Wenn das ListView angeklickt wurde, wird der
  647.                             * angeklickte Eintrag bestimmt, das assozierte
  648.                             * Action command ausgeführt und das Unterprogramm
  649.                             * zum Beenden vorbereitet, falls nach Aktion das
  650.                             * Fenster geschlossen werden soll.
  651.                             */
  652.                         case GD_ActionLV:
  653.                            if (node = GetNode(&DL, code))
  654.                               Command(node, file);
  655.  
  656.                            if(node->ln_Pri == 0)
  657.                            {
  658.                               ClearIntuiMsgPort(ActionWnd);
  659.                               Flags.quit_action_flag = 1;
  660.                            }
  661.                            else
  662.                               node = NULL;
  663.                            break;
  664.                      }
  665.                      break;
  666.  
  667.                      /*
  668.                       * Falls eine Taste betätigt wurde, wird diese
  669.                       * ermittelt und verarbeitet.
  670.                       */
  671.                   case IDCMP_VANILLAKEY:
  672.                      switch(code)
  673.                      {
  674.                            /*
  675.                             * Diese Tasten entsprechen dem Anklicken des
  676.                             * "Info"-Gadgets.
  677.                             */
  678.                         case 'i':
  679.                         case 'I':
  680.                            ShowInfo(file);
  681.                            node = NULL;
  682.                            break;
  683.  
  684.                            /*
  685.                             * Diese Tasten entsprechen dem Anklicken des
  686.                             * Closegadgets des Action windows..
  687.                             */
  688.                         case '\33':
  689.                            Flags.quit_action_flag = 1;
  690.                            ret = FALSE;
  691.                            node = NULL;
  692.                            break;
  693.                      }
  694.                      break;
  695.  
  696.                      /*
  697.                       * Das Fenster wird zum Beenden des Unterprogrammes
  698.                       * vorbereitet.
  699.                       */
  700.                   case IDCMP_CLOSEWINDOW:
  701.                      Flags.quit_action_flag = 1;
  702.                      ret = FALSE;
  703.                      node = NULL;
  704.                      break;
  705.                }
  706.             }
  707.       }
  708.       while (NOT(Flags.quit_action_flag));
  709.  
  710.          /*
  711.           * Das Action window wird geschlossen und der
  712.           * PublicScreen freigegeben.
  713.           */
  714.       CloseASysWindow(&ActionWnd, &ActionGList, NULL);
  715.       CloseDownScreen();
  716.    }
  717.    else
  718.       ErrorHandle(WINDOW_ERR, OPEN_FAIL, NO_KILL);
  719.  
  720.       /*
  721.        * Der Speicher, der für die Liste der Aktionen
  722.        * angelegt wurde, wird freigegeben.
  723.        */
  724.    MyFreeVec(act);
  725.  
  726.    return (ret);
  727. }
  728.  
  729.