home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / rsyssrc.lha / RSysFindFile.c < prev    next >
C/C++ Source or Header  |  1993-09-19  |  19KB  |  745 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *      RSysFindFile.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void FindFile ( void );
  12. *    void HandleFindFileKeys ( ULONG code );
  13. *    void MakeDevEntry ( struct List *list , char *str );
  14. *
  15. *      --- Lokale  Routinen ---
  16. *
  17. *    static BOOL ClickedGadget ( void );
  18. *    static int OpenFindFileWindow ( void );
  19. *    static void *MyDevAllocRem ( long size );
  20. *    static void *MyFileAllocRem ( long size );
  21. *    static void HandleFindFileGadgets ( APTR object , ULONG code );
  22. *    static void MakeDevList ( void );
  23. *    static void MakeFileEntry ( char *str );
  24. *    static void refreshdevlists ( void );
  25. *    static void SaveFoundFiles ( void );
  26. *    static void SearchFile ( char *name );
  27. *
  28. * Bemerkungen:
  29. *      Disk-Format-Untersützung und Dateisuchroutinen.
  30. *
  31. * Erstellungsdatum:
  32. *      07-Jul-93     Rolf Böhme
  33. *
  34. * Änderungen:
  35. *      07-Jul-93     Rolf Böhme      Erstellung
  36. *
  37. ***************************************************************************
  38. */
  39.  
  40. #include "RSys.h"
  41.  
  42. static struct Window *FindFileWnd = NULL;
  43. static struct Gadget *FindFileGList = NULL;
  44. static UWORD FindFileZoom[4];
  45. static struct Gadget *FindFileGadgets[10];
  46. static UWORD FindFileLeft = 153;
  47. static UWORD FindFileTop = 27;
  48. static UWORD FindFileWidth = 330;
  49. static UWORD FindFileHeight = 200;
  50. static UBYTE *FindFileWdt = (UBYTE *) NAME " " VERSION " - Find File";
  51. static UBYTE *CaseCYGad0Labels[]=
  52. {
  53.     (UBYTE *) "No case sense",
  54.     (UBYTE *) "Case sense",
  55.     NULL
  56. };
  57. static UBYTE *DirFileCYGad0Labels[] = {
  58.     (UBYTE *)"Dirs + Files",
  59.     (UBYTE *)"Files",
  60.     (UBYTE *)"Directories",
  61.     NULL };
  62.  
  63. static struct List DevList;
  64. static struct List SelDevList,
  65.         FoundList;
  66.  
  67. struct Remember *DevKey = NULL;
  68. static struct Remember *FileKey = NULL;
  69.  
  70. static char pat[PATTERNLEN],
  71.         parsepat[PARSEPATLEN];
  72. static int    match_case = NO_CASE,
  73.         match_type = DF;
  74.  
  75. static UWORD FindFileGTypes[] = {
  76.     LISTVIEW_KIND,
  77.     LISTVIEW_KIND,
  78.     STRING_KIND,
  79.     BUTTON_KIND,
  80.     LISTVIEW_KIND,
  81.     BUTTON_KIND,
  82.     BUTTON_KIND,
  83.     BUTTON_KIND,
  84.     CYCLE_KIND,
  85.     CYCLE_KIND
  86. };
  87.  
  88. static struct NewGadget FindFileNGad[] = {
  89.     4, 17, 157, 60, (UBYTE *)"Devices", NULL, GD_DeviceLV, PLACETEXT_ABOVE, NULL, NULL,
  90.     168, 17, 157, 60, (UBYTE *)"Selected Devices", NULL, GD_SelDevLV, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  91.     74, 113, 87, 13, (UBYTE *)"Pattern", NULL, GD_PatternGad, PLACETEXT_LEFT, NULL, NULL,
  92.     4, 97, 157, 13, (UBYTE *)"Start/Stop Search", NULL, GD_StartStopGad, PLACETEXT_IN, NULL, NULL,
  93.     4, 144, 321, 52, (UBYTE *)"Found files/dirs", NULL, GD_FoundLV, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  94.     168, 97, 157, 13, (UBYTE *)"Save found list", NULL, GD_SaveFoundListGad, PLACETEXT_IN, NULL, NULL,
  95.     168, 81, 77, 13, (UBYTE *)"Sel all", NULL, GD_AllGad, PLACETEXT_IN, NULL, NULL,
  96.     248, 81, 77, 13, (UBYTE *)"Sel none", NULL, GD_NoneGad, PLACETEXT_IN, NULL, NULL,
  97.     4, 81, 157, 13, NULL, NULL, GD_CaseCYGad, 0, NULL, NULL,
  98.     168, 113, 157, 13, NULL, NULL, GD_DirFileCYGad, 0, NULL, NULL
  99. };
  100.  
  101. static ULONG *FindFileGTags[] = {
  102.     (ULONG *)(GTLV_Labels), (ULONG *)&DevList, (ULONG *)(TAG_DONE),
  103.     (ULONG *)(GTLV_Labels), (ULONG *)&SelDevList, (ULONG *)(TAG_DONE),
  104.     (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  105.     (ULONG *)(GA_Disabled), (ULONG *)TRUE, (ULONG *)(TAG_DONE),
  106.     (ULONG *)(GTLV_Labels), (ULONG *)&FoundList, (ULONG *)(GTLV_ReadOnly), (ULONG *)TRUE, (ULONG *)(TAG_DONE),
  107.     (ULONG *)(TAG_DONE),
  108.     (ULONG *)(TAG_DONE),
  109.     (ULONG *)(TAG_DONE),
  110.     (ULONG * )(GTCY_Labels), (ULONG *)&CaseCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  111.     (ULONG * )(GTCY_Labels), (ULONG *)&DirFileCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE)
  112. };
  113.  
  114. static int gl[] = {GD_DeviceLV - GD_DeviceLV,
  115.                    GD_SelDevLV - GD_DeviceLV,
  116.                    GD_PatternGad - GD_DeviceLV,
  117.                    GD_FoundLV - GD_DeviceLV};
  118.  
  119.     /*
  120.      * OpenFindFileWindow() öffnet ein Window mit Gadgets, mit
  121.      * denen die Auswahl- und Suchkriterien eingegeben werden
  122.      * können
  123.      */
  124. static int
  125. OpenFindFileWindow( void )
  126. {
  127.     struct NewGadget    ng;
  128.     struct Gadget    *g;
  129.     UWORD        lc, tc;
  130.     UWORD        wleft = FindFileLeft, wtop = FindFileTop, ww, wh;
  131.  
  132.     DPOS;
  133.  
  134.    AdjustWindowDimensions(Scr, FindFileLeft, FindFileTop, FindFileWidth, FindFileHeight,
  135.                                &wleft, &wtop, &ww, &wh);
  136.  
  137.     if ( ! ( g = CreateContext( &FindFileGList ))) return 1L;
  138.  
  139.     for( lc = 0, tc = 0; lc < FindFile_CNT; lc++ ) 
  140.    {
  141.         CopyMem((char * )&FindFileNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  142.  
  143.         ng.ng_VisualInfo = VisualInfo;
  144.         ng.ng_TextAttr     = Font;
  145.         ng.ng_LeftEdge     = OffX + ComputeX( ng.ng_LeftEdge );
  146.         ng.ng_TopEdge     = OffY + ComputeY( ng.ng_TopEdge );
  147.         ng.ng_Width         = ComputeX( ng.ng_Width );
  148.         ng.ng_Height      = ComputeY( ng.ng_Height);
  149.  
  150.         FindFileGadgets[ lc ] = g = CreateGadgetA((ULONG)FindFileGTypes[ lc ], g, &ng, ( struct TagItem * )&FindFileGTags[ tc ] );
  151.  
  152.         makelabelvisible(FindFileGadgets[lc]);
  153.  
  154.         while( FindFileGTags[ tc ] ) tc += 2;
  155.         tc++;
  156.  
  157.         if ( NOT g ) return 2L;
  158.     }
  159.  
  160.     FindFileZoom[2] = TextLength( &Scr->RastPort, (UBYTE *)FindFileWdt, strlen((char *)FindFileWdt )) + 80;
  161.     FindFileZoom[0] = FindFileZoom[1] = 0;
  162.     FindFileZoom[3] = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  163.  
  164.     if ( ! ( FindFileWnd = OpenWindowTags( NULL,
  165.                 WA_Left,    wleft,
  166.                 WA_Top,        wtop,
  167.                 WA_Width,    ww,
  168.                 WA_Height,    wh,
  169.                 WA_IDCMP,    IDCMP_VANILLAKEY|
  170.                                 LISTVIEWIDCMP|
  171.                                 STRINGIDCMP|
  172.                                 BUTTONIDCMP|
  173.                                 CYCLEIDCMP|
  174.                                 IDCMP_CLOSEWINDOW|
  175.                                 IDCMP_CHANGEWINDOW|
  176.                                 IDCMP_REFRESHWINDOW,
  177.                 WA_Flags,    WFLG_DRAGBAR|
  178.                                 WFLG_DEPTHGADGET|
  179.                                 WFLG_CLOSEGADGET|
  180.                                 WFLG_RMBTRAP|
  181.                                 WFLG_ACTIVATE |
  182.                                 WFLG_SMART_REFRESH,
  183.                 WA_Title,    FindFileWdt,
  184.                 WA_Zoom,    FindFileZoom,
  185.                 WA_PubScreenFallBack,TRUE,
  186.                 WA_PubScreen, Scr,
  187.                 TAG_DONE )))
  188.         return 4L;
  189.  
  190.     FindFileZoom[0] = FindFileWnd->LeftEdge;
  191.     FindFileZoom[1] = FindFileWnd->TopEdge;
  192.     FindFileZoom[2] = FindFileWnd->Width;
  193.     FindFileZoom[3] = FindFileWnd->Height;
  194.  
  195.     RefreshRastPort(FindFileWnd,FindFileGadgets,gl, 4, FALSE, FindFileGList);
  196.  
  197.     return NULL;
  198. }
  199.  
  200.     /*
  201.      * MyDevAllocRem() reserviert Speicher aus einer Remember-Liste
  202.      * für die Verzeichnis-Einträge
  203.      */
  204. static void *
  205. MyDevAllocRem(long size)
  206. {
  207.     void *ptr = (void *)AllocRemember(DEVKEY, size, MEMF_CLEAR | MEMF_ANY);
  208.  
  209.     if (NOT(ptr))
  210.     {
  211.         ErrorHandle("Device list", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  212.         Flags.quit_ff = 1;
  213.     }
  214.  
  215.     return (ptr);
  216. }
  217.  
  218.     /*
  219.      * MyFileAllocRem() reserviert Speicher aus einer Remember-Liste
  220.      * für die Datei-Einträge
  221.      */
  222. static void *
  223. MyFileAllocRem(long size)
  224. {
  225.     void *ptr = (void *)AllocRemember(FILEKEY, size, MEMF_CLEAR | MEMF_ANY);
  226.  
  227.     if (NOT(ptr))
  228.     {
  229.         ErrorHandle("File list", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  230.         Flags.quit_ff = 1;
  231.     }
  232.  
  233.     return (ptr);
  234. }
  235.  
  236.     /*
  237.      * refreshdevlists() erneuert die Anzeige der ListViews mit den
  238.      * Inhalten der Listen der selektierten und der nicht selektierten
  239.      * Devices
  240.      */
  241. static void
  242. refreshdevlists(void)
  243. {
  244.     InitListView(FindFileWnd,FindFileGadgets[GD_DeviceLV - GD_DeviceLV], &DevList,UNSETLVPOS);
  245.     InitListView(FindFileWnd,FindFileGadgets[GD_SelDevLV - GD_DeviceLV], &SelDevList,UNSETLVPOS);
  246.  
  247.     return;
  248. }
  249.  
  250.     /*
  251.      * MakeDevEntry() erzeugt einen neuen Listeneintrag in die
  252.      * Liste der Devices
  253.      */
  254. void
  255. MakeDevEntry(struct List *list, char *str)
  256. {
  257.     struct Node *node = MyDevAllocRem(sizeof(struct Node));
  258.  
  259.     if (NOT(node)) return;
  260.  
  261.     node->ln_Pri = 0;
  262.     node->ln_Type = NT_USER;
  263.  
  264.     node->ln_Name = MyDevAllocRem(strlen(str) + 1);
  265.     if (NOT(node->ln_Name)) return;
  266.  
  267.     strcpy(node->ln_Name, str);
  268.  
  269.     AddNodeSorted(list, node, 0);
  270.  
  271.     return;
  272. }
  273.  
  274.     /*
  275.      * MakeFileEntry() erzeugt einen Listeneintrag in die Liste der
  276.      * gefundenen Dateien. Der Eintrag wird dann in die bestehende
  277.      * Liste alphabetisch einsortiert
  278.      */
  279. static void
  280. MakeFileEntry(char *str)
  281. {
  282.     struct Node *node = MyFileAllocRem(sizeof(struct Node));
  283.  
  284.     if (NOT(node)) return;
  285.  
  286.     node->ln_Pri = 0;
  287.     node->ln_Type = NT_USER;
  288.     node->ln_Name = MyDevAllocRem(strlen(str) + 1);
  289.  
  290.     if (NOT(node->ln_Name)) return;
  291.  
  292.     strcpy(node->ln_Name, str);
  293.  
  294.     AddNodeSorted(&FoundList, node, 0);
  295.  
  296.     InitListView(FindFileWnd,FindFileGadgets[GD_FoundLV - GD_DeviceLV], &FoundList,UNSETLVPOS);
  297.  
  298.     return;
  299. }
  300.  
  301.  
  302.     /*
  303.      * MakeDevList() erzeugt eine Liste aus angemeldeten Devices
  304.      * (Volumes) und Assigns. Die Devices werden der Reihe nach
  305.      * ausgelesen und in die Liste einsortiert. Assigns werden mit
  306.      * einem führenden "-" versehen, damit sie in der Liste
  307.      * unterschieden werden können
  308.      */
  309. static void
  310. MakeDevList(void)
  311. {
  312.     char    dev[80], str[100];
  313.     struct DosList *dl;
  314.  
  315.     dl = LockDosList(LDF_VOLUMES | LDF_READ);
  316.  
  317.     while (dl = NextDosEntry(dl, LDF_VOLUMES | LDF_READ))
  318.     {
  319.         sprintf(str, " %s:", B2CStr(dev, dl->dol_Name));
  320.         MakeDevEntry(&DevList, str);
  321.     }
  322.  
  323.     UnLockDosList(LDF_VOLUMES | LDF_READ);
  324.  
  325.     dl = LockDosList(LDF_ASSIGNS | LDF_READ);
  326.  
  327.     while (dl = NextDosEntry(dl, LDF_ASSIGNS | LDF_READ))
  328.     {
  329.         sprintf(str, "\-%s:", B2CStr(dev, dl->dol_Name));
  330.         MakeDevEntry(&DevList, str);
  331.     }
  332.  
  333.     UnLockDosList(LDF_ASSIGNS | LDF_READ);
  334.  
  335.     return;
  336. }
  337.  
  338. static int     breakit = FALSE;
  339.  
  340.     /*
  341.      * ClickedGadget() prüft, ob das Start/Stop-Gadget betätigt
  342.      * wurde. Mit einem AutoRequester wird nachgefragt, ob die
  343.      * Suche nach Dateien eingestellt werden soll
  344.      */
  345. static BOOL
  346. ClickedGadget(void)
  347. {
  348.     register struct IntuiMessage *mess;
  349.     ULONG class;
  350.     APTR    adr;
  351.     BOOL    ret = FALSE;
  352.  
  353.     while ((mess = (struct IntuiMessage *) GT_GetIMsg(FindFileWnd->UserPort)) != NULL)
  354.     {
  355.         class = mess->Class;
  356.         adr = mess->IAddress;
  357.  
  358.         GT_ReplyIMsg(mess);
  359.  
  360.         switch (class)
  361.         {
  362.             case IDCMP_CHANGEWINDOW:
  363.             case IDCMP_REFRESHWINDOW:
  364.                 RefreshRastPort(FindFileWnd,FindFileGadgets,gl, 4, TRUE, NULL);
  365.                 MakeWindowRefresh(FindFileWnd);
  366.                 break;
  367.  
  368.             case IDCMP_GADGETUP:
  369.                 if ((adr == (APTR) FindFileGadgets[GD_StartStopGad - GD_DeviceLV]) &&
  370.                      Question(FindFileWnd, "Do you want to cancel searching?", YES))
  371.                 {
  372.                     ret = TRUE;
  373.                     breakit = TRUE;
  374.                 }
  375.                 break;
  376.         }
  377.     }
  378.  
  379.     return ret;
  380. }
  381.  
  382.     /*
  383.      * SearchFile() wird rekursiv mit dem dem Namen eines
  384.      * Verzeichnisses oder Devices aufgerufen. Es durchsucht dann
  385.      * alle Verzeichnisse nach vorgegebenem Suchmuster. Die
  386.      * gefundenen Einträge werden in die entsprechenden Listen
  387.      * eingetragen
  388.      */
  389. static void
  390. SearchFile(char *name)
  391. {
  392.     struct ExAllControl *eac;
  393.     struct ExAllData *EAData,
  394.           *ead;
  395.     int    more;
  396.     BPTR    lock;
  397.     UBYTE newdir[MAXFULLNAME],
  398.             foundname[MAXFULLNAME];
  399.     BOOL(*matchfunc[2]) (UBYTE *, UBYTE *) =
  400.     {
  401.         MatchPatternNoCase, MatchPattern
  402.     };
  403.  
  404.     if (ClickedGadget()|| breakit || Flags.quit_ff) return;
  405.  
  406.     if (NOT(lock = Lock((UBYTE *) name, ACCESS_READ))) return;
  407.  
  408.     if (eac = AllocDosObject(DOS_EXALLCONTROL, NULL))
  409.     {
  410.         eac->eac_LastKey = 0;
  411.  
  412.         EAData = MyAllocVec((MAXLARGEMEM+1) * sizeof(struct ExAllData),
  413.                                   MEMF_ANY | MEMF_CLEAR, NO_KILL);
  414.  
  415.         if (EAData)
  416.         {
  417.             do
  418.             {
  419.                 more = ExAll(lock, EAData, MAXLARGEMEM * sizeof(struct ExAllData),
  420.                                  ED_SIZE, eac);
  421.  
  422.                 if ((!more) && (IoErr()!= ERROR_NO_MORE_ENTRIES))
  423.                 {
  424.                     ErrorHandle(name, DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  425.                     break;
  426.                 }
  427.  
  428.                 if (eac->eac_Entries == 0)
  429.                     continue;
  430.  
  431.                 ead = EAData;
  432.  
  433.                 do
  434.                 {
  435.                     if ((*matchfunc[match_case]) ((UBYTE *) parsepat,
  436.                                                             FilePart((UBYTE *) ead->ed_Name)))
  437.                     {
  438.                         strncpy((char *)foundname, name, MAXFULLNAME);
  439.                         if (AddPart(foundname, ead->ed_Name, MAXFULLNAME))
  440.                         {
  441.                             if (ead->ed_Type > 0) strcat((char *)foundname, " (dir)");
  442.  
  443.                             if((match_type == DF) || ((match_type == FI) && (ead->ed_Type <= 0)) ||
  444.                                 ((match_type == DI) && (ead->ed_Type >  0)))
  445.                             MakeFileEntry((char *)foundname);
  446.                         }
  447.                     }
  448.  
  449.                     if (ead->ed_Type > 0)
  450.                     {
  451.                         strncpy((char *)newdir, name, MAXFULLNAME);
  452.  
  453.                         if (AddPart(newdir, ead->ed_Name, MAXFULLNAME)) SearchFile((char *)newdir);
  454.                     }
  455.  
  456.                     ead = ead->ed_Next;
  457.                 } while (ead && NOT(ClickedGadget())&& NOT(breakit) && NOT(Flags.quit_ff));
  458.  
  459.             } while (more);
  460.  
  461.             MyFreeVec(EAData);
  462.         }
  463.  
  464.         FreeDosObject(DOS_EXALLCONTROL, eac);
  465.     }
  466.     else ErrorHandle("ExAll()-Control", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  467.  
  468.     UnLock(lock);
  469.  
  470.     return;
  471. }
  472.  
  473.     /*
  474.      * SaveFoundFiles() speichert die Liste mit den gefunden
  475.      * Dateien und Verzeichnissen in einer Datei ab
  476.      */
  477. static void
  478. SaveFoundFiles(void)
  479. {
  480.     char    head[PARSEPATLEN];
  481.  
  482.     if (GetFile(FindFileWnd,"RAM:","RSys-FoundFiles.DAT","#?.DAT", 
  483.                "Select File for saving list","Save"))
  484.     {
  485.         sprintf(head, "Found files (Pattern: %s)", pat);
  486.         SaveList(FindFileWnd, (char *)_fullpath, head, &FoundList, FALSE);
  487.     }
  488.  
  489.     return;
  490. }
  491.  
  492. static void
  493. HandleFindFileGadgets(APTR object, ULONG code)
  494. {
  495.     struct Node *clicknode,
  496.           *node,
  497.           *remnode;
  498.    int ID, i;
  499.     LONG (*parse_func[2]) (UBYTE *, UBYTE *, long)=
  500.     {
  501.         ParsePatternNoCase, ParsePattern
  502.     };
  503.  
  504.     DPOS;
  505.  
  506.    ID = ((struct Gadget *) object)->GadgetID;
  507.  
  508.    HandleHelp((enum RSysNumbers)ID);
  509.  
  510.     switch (ID)
  511.     {
  512.         case GD_DeviceLV:
  513.             clicknode = GetNode(&DevList, code);
  514.             Remove(clicknode);
  515.             AddTail(&SelDevList, clicknode);
  516.             refreshdevlists();
  517.  
  518.             if (strlen(pat)) EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  519.             break;
  520.  
  521.         case GD_SelDevLV:
  522.             clicknode = GetNode(&SelDevList, code);
  523.             Remove(clicknode);
  524.             AddNodeSorted(&DevList, clicknode, 0);
  525.             refreshdevlists();
  526.  
  527.             if (IsListEmpty(&SelDevList)) EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  528.             break;
  529.  
  530.         case GD_PatternGad:
  531.             strncpy(pat, gadgetbuff(FindFileGadgets[GD_PatternGad - GD_DeviceLV]), PATTERNLEN);
  532.  
  533.             if (strlen(pat) == 0)
  534.                 EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  535.             else if ((*parse_func[match_case]) ((UBYTE *) pat, (UBYTE *) parsepat, 162) < 0)
  536.                 EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  537.             else if (NOT(IsListEmpty(&SelDevList)))
  538.                 EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  539.  
  540.             break;
  541.  
  542.         case GD_StartStopGad:
  543.             if (NOT(IsListEmpty(&SelDevList)))
  544.             {
  545.                 if (NOT(IsListEmpty(&FoundList)) && Question(FindFileWnd, "File list not empty!\n"
  546.                                                          "Do you want to save it?", NO))
  547.                     SaveFoundFiles();
  548.  
  549.                 InitListView(FindFileWnd,FindFileGadgets[GD_FoundLV - GD_DeviceLV], NULL,0);
  550.  
  551.                 FreeRemember(FILEKEY, TRUE);
  552.                 NewList(&FoundList);
  553.  
  554.                 InitListView(FindFileWnd,FindFileGadgets[GD_FoundLV - GD_DeviceLV], &FoundList,UNSETLVPOS);
  555.  
  556.                 for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
  557.                     if ((i != GD_StartStopGad) && (i != GD_FoundLV))
  558.                         EnableGadget(FindFileWnd,FindFileGadgets[i - GD_DeviceLV], FALSE);
  559.  
  560.                 breakit = FALSE;
  561.  
  562.                 for (node = SelDevList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  563.                     SearchFile(&(node->ln_Name)[1]);
  564.  
  565.                 for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
  566.                     if ((i != GD_StartStopGad) && (i != GD_FoundLV))
  567.                         EnableGadget(FindFileWnd,FindFileGadgets[i - GD_DeviceLV], TRUE);
  568.             }
  569.             break;
  570.  
  571.         case GD_SaveFoundListGad:
  572.             if (NOT(IsListEmpty(&FoundList))) SaveFoundFiles();
  573.             break;
  574.  
  575.         case GD_AllGad:
  576.             if (IsListEmpty(&DevList)) break;
  577.  
  578.             node = DevList.lh_Head;
  579.             while (node->ln_Succ)
  580.             {
  581.                 remnode = node->ln_Succ;
  582.                 Remove(node);
  583.                 AddTail(&SelDevList, node);
  584.                 node = remnode;
  585.             }
  586.  
  587.             InitListView(FindFileWnd,FindFileGadgets[GD_DeviceLV - GD_DeviceLV], NULL,0);
  588.             NewList(&DevList);
  589.  
  590.             refreshdevlists();
  591.             if (strlen(pat)) EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  592.             break;
  593.  
  594.         case GD_NoneGad:
  595.             if (IsListEmpty(&SelDevList))    break;
  596.  
  597.             node = SelDevList.lh_Head;
  598.             while (node->ln_Succ)
  599.             {
  600.                 remnode = node->ln_Succ;
  601.                 Remove(node);
  602.                 AddNodeSorted(&DevList, node, 0);
  603.                 node = remnode;
  604.             }
  605.  
  606.             InitListView(FindFileWnd,FindFileGadgets[GD_SelDevLV - GD_DeviceLV], NULL,0);
  607.             NewList(&SelDevList);
  608.  
  609.             refreshdevlists();
  610.             EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  611.  
  612.             break;
  613.  
  614.         case GD_CaseCYGad:
  615.             match_case = ((match_case == CASE) ? NO_CASE : CASE);
  616.             if (strlen(pat) == 0)
  617.                 EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  618.             else if ((*parse_func[match_case]) ((UBYTE *) pat, (UBYTE *) parsepat, 162) < 0)
  619.                 EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
  620.             else
  621.                 EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
  622.             break;
  623.  
  624.         case GD_DirFileCYGad:
  625.             match_type = code;
  626.             break;
  627.     }
  628.  
  629.    return;
  630. }
  631.  
  632. void
  633. HandleFindFileKeys(ULONG code)
  634. {
  635.     if (code == ESC)
  636.     {
  637.         if (NOT(IsListEmpty(&FoundList)) && Question(FindFileWnd, "File list not empty!\n"
  638.                                                    "Do you want to save it?", NO))
  639.             SaveFoundFiles();
  640.  
  641.         Flags.quit_ff = 1;
  642.     }
  643.  
  644.    return;
  645. }
  646.  
  647.     /*
  648.      * FindFile() präsentiert eine Benutzeroberfläche, mit der die
  649.      * Suchkriterien eingestellt und das Handling gemanagt wird
  650.      */
  651. void
  652. FindFile(void)
  653. {
  654.     register struct IntuiMessage *message;
  655.     ULONG class,
  656.             code;
  657.     APTR    object;
  658.     static int refr = TRUE;
  659.  
  660.     DPOS;
  661.  
  662.    HandleHelp(MN_FindFile);
  663.  
  664.     NewList(&DevList);
  665.     NewList(&SelDevList);
  666.     NewList(&FoundList);
  667.  
  668.     Flags.quit_ff = 0;
  669.  
  670.     if (OpenASysWindow(OpenFindFileWindow,NO_KILL))
  671.     {
  672.       LockMainWindow(LOCK);
  673.  
  674.         MakeDevList();
  675.         InitListView(FindFileWnd,FindFileGadgets[GD_DeviceLV - GD_DeviceLV], &DevList,UNSETLVPOS);
  676.  
  677.         do
  678.         {
  679.             Wait(1L << FindFileWnd->UserPort->mp_SigBit);
  680.  
  681.             while ((message = (struct IntuiMessage *) GT_GetIMsg(FindFileWnd->UserPort)) != NULL)
  682.             {
  683.                 object = message->IAddress;
  684.                 class = message->Class;
  685.                 code = message->Code;
  686.  
  687.                 GT_ReplyIMsg(message);
  688.  
  689.                 switch (class)
  690.                 {
  691.                     case IDCMP_GADGETUP:
  692.                   HandleFindFileGadgets(object, code);
  693.                   break;
  694.  
  695.                     case IDCMP_VANILLAKEY:
  696.                   HandleFindFileKeys(code);
  697.                         break;
  698.  
  699.                     case IDCMP_CHANGEWINDOW:
  700.                     case IDCMP_REFRESHWINDOW:
  701.                         if (NOT(FindFileWnd->Flags & WFLG_ZOOMED))
  702.                         {
  703.                                 /*
  704.                                  * Das Fenster soll nur EINMAL refreshed werden.
  705.                                  * Diese IDCMP-Message kommt aber auch dann, wenn ein
  706.                                  * Fenster verschoben wurde, weshalb ein Flag extra
  707.                                  * eingeführt wurde.
  708.                                  */
  709.                             if (NOT(refr))
  710.                             {
  711.                                RefreshRastPort(FindFileWnd,FindFileGadgets,gl, 4, TRUE, NULL);
  712.  
  713.                                 refr = TRUE;
  714.                             }
  715.                         }
  716.                         else
  717.                             refr = FALSE;
  718.  
  719.                         MakeWindowRefresh(FindFileWnd);
  720.                         break;
  721.  
  722.                     case IDCMP_CLOSEWINDOW:
  723.                         if (NOT(IsListEmpty(&FoundList)) && Question(FindFileWnd, "File list not empty!\n"
  724.                                                                "Do you want to save it?", NO))
  725.                             SaveFoundFiles();
  726.  
  727.                         Flags.quit_ff = 1;
  728.                         break;
  729.                 }
  730.             }
  731.         }
  732.         while (NOT(Flags.quit_ff));
  733.  
  734.         FreeRemember(FILEKEY, TRUE);
  735.         FreeRemember(DEVKEY, TRUE);
  736.  
  737.         CloseASysWindow(&FindFileWnd, &FindFileGList, NULL);
  738.  
  739.       LockMainWindow(UNLOCK);
  740.     }
  741.  
  742.     return;
  743. }
  744.  
  745.