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