home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / monitors / rsys / source.lha / src / RSysFormatFind.c < prev    next >
C/C++ Source or Header  |  1995-01-09  |  35KB  |  1,196 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysFormatFind.c
  6. *
  7. * Inhalt:
  8. *    int OpenFindFileWindow(void);
  9. *    void FindFile(void);
  10. *    int OpenFormatDiskWindow(void);
  11. *    void FormatDisk(void);
  12. *
  13. * Bemerkungen:
  14. *    Disk-Format-Untersützung und Dateisuchroutinen.
  15. *
  16. * Erstellungsdatum:
  17. *    07-Jul-93    Rolf Böhme
  18. *
  19. * Änderungen:
  20. *    07-Jul-93    Rolf Böhme    Erstellung
  21. *
  22. ***************************************************************************
  23. */
  24.  
  25. #include "RSysFunc.h"
  26. #include "RSysDebug.h"
  27.  
  28. static enum gadid
  29. {
  30.    GD_DeviceLV,
  31.    GD_SelDevLV,
  32.    GD_PatternGad,
  33.    GD_StartStopGad,
  34.    GD_FoundLV,
  35.    GD_SaveFoundListGad,
  36.    GD_AllGad,
  37.    GD_NoneGad,
  38.    GD_CaseCYGad,
  39.    GD_DirFileCYGad
  40. };
  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. #define DF 0
  64. #define FI 1
  65. #define DI 2
  66.  
  67. static struct List DevList;
  68. static struct List SelDevList,
  69.       FoundList;
  70.  
  71. struct Remember *DevKey = NULL;
  72. static struct Remember *FileKey = NULL;
  73.  
  74. static char pat[PATTERNLEN],
  75.       parsepat[PARSEPATLEN];
  76. static int  match_case = NO_CASE,
  77.       match_type = DF;
  78.  
  79. #define DEVKEY    ((struct Remember **)&DevKey)
  80. #define FILEKEY   ((struct Remember **)&FileKey)
  81.  
  82. #define FindFile_CNT 10
  83.  
  84. static UWORD FindFileGTypes[] = {
  85.     LISTVIEW_KIND,
  86.     LISTVIEW_KIND,
  87.     STRING_KIND,
  88.     BUTTON_KIND,
  89.     LISTVIEW_KIND,
  90.     BUTTON_KIND,
  91.     BUTTON_KIND,
  92.     BUTTON_KIND,
  93.     CYCLE_KIND,
  94.     CYCLE_KIND
  95. };
  96.  
  97. int gl[] = {GD_DeviceLV,GD_SelDevLV,GD_PatternGad,GD_FoundLV};
  98.  
  99. static struct NewGadget FindFileNGad[] = {
  100.     4, 17, 157, 60, (UBYTE *)"Devices", NULL, GD_DeviceLV, PLACETEXT_ABOVE, NULL, NULL,
  101.     168, 17, 157, 60, (UBYTE *)"Selected Devices", NULL, GD_SelDevLV, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  102.     74, 113, 87, 13, (UBYTE *)"Pattern", NULL, GD_PatternGad, PLACETEXT_LEFT, NULL, NULL,
  103.     4, 97, 157, 13, (UBYTE *)"Start/Stop Search", NULL, GD_StartStopGad, PLACETEXT_IN, NULL, NULL,
  104.     4, 144, 321, 52, (UBYTE *)"Found files/dirs", NULL, GD_FoundLV, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  105.     168, 97, 157, 13, (UBYTE *)"Save found list", NULL, GD_SaveFoundListGad, PLACETEXT_IN, NULL, NULL,
  106.     168, 81, 77, 13, (UBYTE *)"Sel all", NULL, GD_AllGad, PLACETEXT_IN, NULL, NULL,
  107.     248, 81, 77, 13, (UBYTE *)"Sel none", NULL, GD_NoneGad, PLACETEXT_IN, NULL, NULL,
  108.     4, 81, 157, 13, NULL, NULL, GD_CaseCYGad, 0, NULL, NULL,
  109.     168, 113, 157, 13, NULL, NULL, GD_DirFileCYGad, 0, NULL, NULL
  110. };
  111.  
  112. static ULONG *FindFileGTags[] = {
  113.     (ULONG *)(GTLV_Labels), (ULONG *)&DevList, (ULONG *)(TAG_DONE),
  114.     (ULONG *)(GTLV_Labels), (ULONG *)&SelDevList, (ULONG *)(TAG_DONE),
  115.     (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  116.     (ULONG *)(GA_Disabled), (ULONG *)TRUE, (ULONG *)(TAG_DONE),
  117.     (ULONG *)(GTLV_Labels), (ULONG *)&FoundList, (ULONG *)(GTLV_ReadOnly), (ULONG *)TRUE, (ULONG *)(TAG_DONE),
  118.     (ULONG *)(TAG_DONE),
  119.     (ULONG *)(TAG_DONE),
  120.     (ULONG *)(TAG_DONE),
  121.     (ULONG * )(GTCY_Labels), (ULONG *)&CaseCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  122.     (ULONG * )(GTCY_Labels), (ULONG *)&DirFileCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE)
  123. };
  124.  
  125.    /*
  126.     * OpenFindFileWindow() öffnet ein Window mit Gadgets, mit
  127.     * denen die Auswahl- und Suchkriterien eingegeben werden
  128.     * können
  129.     */
  130. int
  131. OpenFindFileWindow( void )
  132. {
  133.     struct NewGadget    ng;
  134.     struct Gadget    *g;
  135.     UWORD        lc, tc;
  136.     UWORD        wleft = FindFileLeft, wtop = FindFileTop, ww, wh;
  137.    int gl[] = {GD_DeviceLV,GD_SelDevLV,GD_PatternGad,GD_FoundLV};
  138.  
  139.    DPOS;
  140.  
  141.     ComputeFont( Scr,FindFileWidth, FindFileHeight );
  142.  
  143.     ww = ComputeX( FindFileWidth );
  144.     wh = ComputeY( FindFileHeight );
  145.  
  146.     if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
  147.     if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;
  148.  
  149.    ww = compute((UWORD) (OffX + Scr->WBorRight), FontX, (int)FindFileWidth);
  150.    wh = compute((UWORD) (OffY + Scr->WBorBottom), FontY, (int)FindFileHeight);
  151.  
  152.    CenterWindow(Scr, &wtop, &wleft, ww, wh);
  153.  
  154.     if ( ! ( g = CreateContext( &FindFileGList )))
  155.         return( 1L );
  156.  
  157.     for( lc = 0, tc = 0; lc < FindFile_CNT; lc++ ) {
  158.  
  159.         CopyMem((char * )&FindFileNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  160.  
  161.         ng.ng_VisualInfo = VisualInfo;
  162.         ng.ng_TextAttr   = Font;
  163.         ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  164.         ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  165.         ng.ng_Width      = ComputeX( ng.ng_Width );
  166.         ng.ng_Height     = ComputeY( ng.ng_Height);
  167.  
  168.         FindFileGadgets[ lc ] = g = CreateGadgetA((ULONG)FindFileGTypes[ lc ], g, &ng, ( struct TagItem * )&FindFileGTags[ tc ] );
  169.  
  170.       makelabelvisible(FindFileGadgets[lc]);
  171.  
  172.         while( FindFileGTags[ tc ] ) tc += 2;
  173.         tc++;
  174.  
  175.         if ( NOT g )
  176.             return( 2L );
  177.     }
  178.  
  179.     FindFileZoom[2] = TextLength( &Scr->RastPort, (UBYTE *)FindFileWdt, strlen((char *)FindFileWdt )) + 80;
  180.     FindFileZoom[0] = FindFileZoom[1] = 0;
  181.     FindFileZoom[3] = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  182.  
  183.     if ( ! ( FindFileWnd = OpenWindowTags( NULL,
  184.                 WA_Left,    wleft,
  185.                 WA_Top,        wtop,
  186.                 WA_Width,    ww, /* + OffX + Scr->WBorRight,*/
  187.                 WA_Height,    wh, /* + OffY + Scr->WBorBottom,*/
  188.                 WA_IDCMP,    IDCMP_VANILLAKEY|
  189.                         LISTVIEWIDCMP|
  190.                         STRINGIDCMP|
  191.                         BUTTONIDCMP|
  192.                         CYCLEIDCMP|
  193.                         IDCMP_CLOSEWINDOW|
  194.                         IDCMP_CHANGEWINDOW|
  195.                         IDCMP_REFRESHWINDOW,
  196.                 WA_Flags,    WFLG_DRAGBAR|
  197.                         WFLG_DEPTHGADGET|
  198.                         WFLG_CLOSEGADGET|
  199.                         WFLG_RMBTRAP|
  200.                         WFLG_ACTIVATE |
  201.                         WFLG_SMART_REFRESH,
  202.             WA_Gadgets,    FindFileGList,
  203.             WA_Title,    FindFileWdt,
  204.             WA_Zoom,    FindFileZoom,
  205.             WA_PubScreenFallBack,TRUE,
  206.             WA_PubScreen, Scr,
  207.             TAG_DONE )))
  208.        return( 4L );
  209.  
  210.     FindFileZoom[0] = FindFileWnd->LeftEdge;
  211.     FindFileZoom[1] = FindFileWnd->TopEdge;
  212.     FindFileZoom[2] = FindFileWnd->Width;
  213.     FindFileZoom[3] = FindFileWnd->Height;
  214.  
  215.    RefreshRastPort(FindFileWnd,FindFileGadgets,gl, 4);
  216.  
  217.     return( 0L );
  218. }
  219.  
  220.    /*
  221.     * MyDevAllocRem() reserviert Speicher aus einer Remember-Liste
  222.     * für die Verzeichnis-Einträge
  223.     */
  224. static void *
  225. MyDevAllocRem(long size)
  226. {
  227.    void *ptr = (void *)AllocRemember(DEVKEY, size, MEMF_CLEAR | MEMF_ANY);
  228.  
  229.    if (NOT(ptr))
  230.    {
  231.       ErrorHandle(MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  232.       Flags.quit_ff = 1;
  233.    }
  234.  
  235.    return (ptr);
  236. }
  237.  
  238.    /*
  239.     * MyFileAllocRem() reserviert Speicher aus einer Remember-Liste
  240.     * für die Datei-Einträge
  241.     */
  242. static void *
  243. MyFileAllocRem(long size)
  244. {
  245.    void *ptr = (void *)AllocRemember(FILEKEY, size, MEMF_CLEAR | MEMF_ANY);
  246.  
  247.    if (NOT(ptr))
  248.    {
  249.       ErrorHandle(MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  250.       Flags.quit_ff = 1;
  251.    }
  252.  
  253.    return (ptr);
  254. }
  255.  
  256.    /*
  257.     * refreshdevlists() erneuert die Anzeige der ListViews mit den
  258.     * Inhalten der Listen der selektierten und der nicht selektierten
  259.     * Devices
  260.     */
  261. static void
  262. refreshdevlists(void)
  263. {
  264.    InitListView(FindFileWnd,FindFileGadgets[GD_DeviceLV],
  265.                 &DevList,UNSETLVPOS);
  266.    InitListView(FindFileWnd,FindFileGadgets[GD_SelDevLV],
  267.                 &SelDevList,UNSETLVPOS);
  268.    return;
  269. }
  270.  
  271.    /*
  272.     * MakeDevEntry() erzeugt einen neuen Listeneintrag in die
  273.     * Liste der Devices
  274.     */
  275. static void
  276. MakeDevEntry(struct List *list, char *str)
  277. {
  278.    struct Node *node = MyDevAllocRem(sizeof(struct Node));
  279.  
  280.    if (NOT(node))
  281.       return;
  282.  
  283.    node->ln_Pri = 0;
  284.    node->ln_Type = NT_USER;
  285.    node->ln_Name = MyDevAllocRem(strlen(str) + 1);
  286.  
  287.    if (NOT(node->ln_Name))
  288.       return;
  289.  
  290.    strcpy(node->ln_Name, str);
  291.  
  292.    AddNodeSorted(list, node);
  293.  
  294.    return;
  295. }
  296.  
  297.    /*
  298.     * MakeFileEntry() erzeugt einen Listeneintrag in die Liste der
  299.     * gefundenen Dateien. Der Eintrag wird dann in die bestehende
  300.     * Liste alphabetisch einsortiert
  301.     */
  302. static void
  303. MakeFileEntry(char *str)
  304. {
  305.    struct Node *node = MyFileAllocRem(sizeof(struct Node));
  306.  
  307.    if (NOT(node))
  308.       return;
  309.  
  310.    node->ln_Pri = 0;
  311.    node->ln_Type = NT_USER;
  312.    node->ln_Name = MyDevAllocRem(strlen(str) + 1);
  313.  
  314.    if (NOT(node->ln_Name))
  315.       return;
  316.  
  317.    strcpy(node->ln_Name, str);
  318.  
  319.    AddNodeSorted(&FoundList, node);
  320.    InitListView(FindFileWnd,FindFileGadgets[GD_FoundLV],
  321.                 &FoundList,UNSETLVPOS);
  322.  
  323.    return;
  324. }
  325.  
  326.  
  327.    /*
  328.     * MakeDevList() erzeugt eine Liste aus angemeldeten Devices
  329.     * (Volumes) und Assigns. Die Devices werden der Reihe nach
  330.     * ausgelesen und in die Liste einsortiert. Assigns werden mit
  331.     * einem führenden "-" versehen, damit sie in der Liste
  332.     * unterschieden werden können
  333.     */
  334. static void
  335. MakeDevList(void)
  336. {
  337.    char  dev[80],
  338.          str[100];
  339.    struct DosList *dl;
  340.  
  341.    dl = LockDosList(LDF_VOLUMES | LDF_READ);
  342.  
  343.    while (dl = NextDosEntry(dl, LDF_VOLUMES | LDF_READ))
  344.    {
  345.       sprintf(str, " %s:", B2CStr(dev, dl->dol_Name));
  346.       MakeDevEntry(&DevList, str);
  347.    }
  348.  
  349.    UnLockDosList(LDF_VOLUMES | LDF_READ);
  350.  
  351.    dl = LockDosList(LDF_ASSIGNS | LDF_READ);
  352.  
  353.    while (dl = NextDosEntry(dl, LDF_ASSIGNS | LDF_READ))
  354.    {
  355.       sprintf(str, "\-%s:", B2CStr(dev, dl->dol_Name));
  356.       MakeDevEntry(&DevList, str);
  357.    }
  358.  
  359.    UnLockDosList(LDF_ASSIGNS | LDF_READ);
  360.  
  361.    return;
  362. }
  363.  
  364. static int   breakit = FALSE;
  365.  
  366.    /*
  367.     * ClickedGadget() prüft, ob das Start/Stop-Gadget betätigt
  368.     * wurde. Mit einem AutoRequester wird nachgefragt, ob die
  369.     * Suche nach Dateien eingestellt werden soll
  370.     */
  371. static BOOL
  372. ClickedGadget(void)
  373. {
  374.    register struct IntuiMessage *mess;
  375.    ULONG class;
  376.    APTR  adr;
  377.    BOOL  ret = FALSE;
  378.  
  379.    while ((mess = (struct IntuiMessage *)
  380.            GT_GetIMsg(FindFileWnd->UserPort)) != NULL)
  381.    {
  382.       class = mess->Class;
  383.       adr = mess->IAddress;
  384.  
  385.       GT_ReplyIMsg(mess);
  386.  
  387.       switch (class)
  388.       {
  389.          case IDCMP_CHANGEWINDOW:
  390.          case IDCMP_REFRESHWINDOW:
  391.             RefreshRastPort(FindFileWnd,FindFileGadgets,gl, 4);
  392.             MakeWindowRefresh(FindFileWnd);
  393.             break;
  394.  
  395.          case IDCMP_GADGETUP:
  396.             if ((adr == (APTR) FindFileGadgets[GD_StartStopGad]) &&
  397.                 Question(FindFileWnd, "Do you want to cancel searching?", YES))
  398.             {
  399.                ret = TRUE;
  400.                breakit = TRUE;
  401.             }
  402.             break;
  403.       }
  404.    }
  405.  
  406.    return (ret);
  407. }
  408.  
  409.    /*
  410.     * SearchFile() wird rekursiv mit dem dem Namen eines
  411.     * Verzeichnisses oder Devices aufgerufen. Es durchsucht dann
  412.     * alle Verzeichnisse nach vorgegebenem Suchmuster. Die
  413.     * gefundenen Einträge werden in die entsprechenden Listen
  414.     * eingetragen
  415.     */
  416. static void
  417. SearchFile(char *name)
  418. {
  419.    struct ExAllControl *eac;
  420.    struct ExAllData *EAData,
  421.         *ead,
  422.         *eadtmp;
  423.    int   more;
  424.    BPTR  lock;
  425.    UBYTE newdir[MAXFULLNAME],
  426.          foundname[MAXFULLNAME];
  427.    BOOL(*matchfunc[2]) (UBYTE *, UBYTE *) =
  428.    {
  429.       MatchPatternNoCase, MatchPattern
  430.    };
  431.  
  432.    if (ClickedGadget()|| breakit || Flags.quit_ff)
  433.       return;
  434.  
  435.    if (NOT(lock = Lock((UBYTE *) name, ACCESS_READ)))
  436.       return;
  437.  
  438.    if (eac = AllocDosObject(DOS_EXALLCONTROL, NULL))
  439.    {
  440.       eac->eac_LastKey = 0;
  441.  
  442.       EAData = MyAllocVec((MAXLARGEMEM+1) * sizeof(struct ExAllData),
  443.                           MEMF_ANY | MEMF_CLEAR, NO_KILL);
  444.  
  445.       if (EAData)
  446.       {
  447.          do
  448.          {
  449.             more = ExAll(lock, EAData, MAXLARGEMEM * sizeof(struct ExAllData),
  450.                          ED_SIZE, eac);
  451.  
  452.             if ((!more) && (IoErr()!= ERROR_NO_MORE_ENTRIES))
  453.             {
  454.                ErrorHandle(DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  455.                break;
  456.             }
  457.  
  458.             if (eac->eac_Entries == 0)
  459.                continue;
  460.  
  461.             ead = EAData;
  462.  
  463.             do
  464.             {
  465.                if ((*matchfunc[match_case]) ((UBYTE *) parsepat,
  466.                                              FilePart((UBYTE *) ead->ed_Name)))
  467.                {
  468.                   strncpy((char *)foundname, name, MAXFULLNAME);
  469.                   if (AddPart(foundname, ead->ed_Name, MAXFULLNAME))
  470.                   {
  471.                      if (ead->ed_Type > 0)
  472.                         strcat((char *)foundname, " (dir)");
  473.  
  474.                      if((match_type == DF) ||
  475.                         ((match_type == FI) && (ead->ed_Type <= 0)) ||
  476.                         ((match_type == DI) && (ead->ed_Type >  0)))
  477.                      MakeFileEntry((char *)foundname);
  478.                   }
  479.                }
  480.  
  481.                if (ead->ed_Type > 0)
  482.                {
  483.                   strncpy((char *)newdir, name, MAXFULLNAME);
  484.  
  485.                   if (AddPart(newdir, ead->ed_Name, MAXFULLNAME))
  486.                      SearchFile((char *)newdir);
  487.                }
  488.  
  489.                ead = ead->ed_Next;
  490.             }
  491.             while (ead && NOT(ClickedGadget())&& NOT(breakit) && NOT(Flags.quit_ff));
  492.  
  493.          }
  494.          while (more);
  495.  
  496.          MyFreeVec(EAData);
  497.       }
  498.  
  499.       FreeDosObject(DOS_EXALLCONTROL, eac);
  500.    }
  501.    else
  502.       ErrorHandle(MEMORY_ERR, ALLOC_FAIL, NO_KILL);
  503.  
  504.    UnLock(lock);
  505.  
  506.    return;
  507. }
  508.  
  509.    /*
  510.     * SaveFoundFiles() speichert die Liste mit den gefunden
  511.     * Dateien und Verzeichnissen in einer Datei ab
  512.     */
  513. static void
  514. SaveFoundFiles(void)
  515. {
  516.    char  head[PARSEPATLEN];
  517.  
  518.    if (GetFile(FindFileWnd,"RAM:","RSys-FoundFiles.DAT","#?.DAT",
  519.                "Select File for saving list","Save"))
  520.    {
  521.       sprintf(head, "Found files (Pattern: %s)", pat);
  522.       SaveList(FindFileWnd, (char *)_fullpath, head, &FoundList, FALSE);
  523.    }
  524.  
  525.    return;
  526. }
  527.  
  528.    /*
  529.     * FindFile() präsentiert eine Benutzeroberfläche, mit der die
  530.     * Suchkriterien eingestellt und das Handling gemanagt wird
  531.     */
  532. void
  533. FindFile(void)
  534. {
  535.    register struct IntuiMessage *message;
  536.    struct Node *clicknode,
  537.         *node,
  538.         *remnode;
  539.    ULONG class,
  540.          code;
  541.    APTR  object;
  542.    APTR  req = NULL;
  543.    register enum gadid i;
  544.    LONG (*parse_func[2]) (UBYTE *, UBYTE *, long)=
  545.    {
  546.       ParsePatternNoCase, ParsePattern
  547.    };
  548.  
  549.    DPOS;
  550.  
  551.    NewList(&DevList);
  552.    NewList(&SelDevList);
  553.    NewList(&FoundList);
  554.    Flags.quit_ff = 0;
  555.  
  556.    if (OpenASysWindow(OpenFindFileWindow,NO_KILL))
  557.    {
  558.       if (SysWnd)
  559.          req = LockWindow(SysWnd);
  560.  
  561.       MakeDevList();
  562.       InitListView(FindFileWnd,FindFileGadgets[GD_DeviceLV],
  563.                    &DevList,UNSETLVPOS);
  564.  
  565.       do
  566.       {
  567.          Wait(1L << FindFileWnd->UserPort->mp_SigBit);
  568.  
  569.          while ((message = (struct IntuiMessage *)
  570.                  GT_GetIMsg(FindFileWnd->UserPort)) != NULL)
  571.          {
  572.             object = message->IAddress;
  573.             class = message->Class;
  574.             code = message->Code;
  575.  
  576.             GT_ReplyIMsg(message);
  577.  
  578.             switch (class)
  579.             {
  580.                case IDCMP_GADGETUP:
  581.                   switch (((struct Gadget *) object)->GadgetID)
  582.                   {
  583.                      case GD_DeviceLV:
  584.                         clicknode = GetNode(&DevList, code);
  585.                         Remove(clicknode);
  586.                         AddTail(&SelDevList, clicknode);
  587.                         refreshdevlists();
  588.  
  589.                         if (strlen(pat))
  590.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], TRUE);
  591.                         break;
  592.  
  593.                      case GD_SelDevLV:
  594.                         clicknode = GetNode(&SelDevList, code);
  595.                         Remove(clicknode);
  596.                         AddNodeSorted(&DevList, clicknode);
  597.                         refreshdevlists();
  598.  
  599.                         if (IsListEmpty(&SelDevList))
  600.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], FALSE);
  601.                         break;
  602.  
  603.                      case GD_PatternGad:
  604.                         strncpy(pat, gadgetbuff(FindFileGadgets[GD_PatternGad]),
  605.                                PATTERNLEN);
  606.  
  607.                         if (strlen(pat) == 0)
  608.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], FALSE);
  609.                         else if ((*parse_func[match_case]) ((UBYTE *) pat,
  610.                                                             (UBYTE *) parsepat, 162) < 0)
  611.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], FALSE);
  612.                         else if (NOT(IsListEmpty(&SelDevList)))
  613.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], TRUE);
  614.  
  615.                         break;
  616.  
  617.                      case GD_StartStopGad:
  618.                         if (NOT(IsListEmpty(&SelDevList)))
  619.                         {
  620.                            if (NOT(IsListEmpty(&FoundList)) &&
  621.                                Question(FindFileWnd, "File list not empty!\n"
  622.                                         "Do you want to save it?", NO))
  623.                               SaveFoundFiles();
  624.  
  625.                            InitListView(FindFileWnd,FindFileGadgets[GD_FoundLV],
  626.                                         NULL,0);
  627.  
  628.                            FreeRemember(FILEKEY, TRUE);
  629.                            NewList(&FoundList);
  630.  
  631.                            InitListView(FindFileWnd,FindFileGadgets[GD_FoundLV],
  632.                                         &FoundList,UNSETLVPOS);
  633.  
  634.                            for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
  635.                               if ((i != GD_StartStopGad) && (i != GD_FoundLV))
  636.                                  EnableGadget(FindFileWnd,FindFileGadgets[i], FALSE);
  637.  
  638.                            breakit = FALSE;
  639.  
  640.                            for (node = SelDevList.lh_Head; node->ln_Succ; node = node->ln_Succ)
  641.                               SearchFile(&(node->ln_Name)[1]);
  642.  
  643.                            for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
  644.                               if ((i != GD_StartStopGad) && (i != GD_FoundLV))
  645.                                  EnableGadget(FindFileWnd,FindFileGadgets[i], TRUE);
  646.                         }
  647.                         break;
  648.  
  649.                      case GD_SaveFoundListGad:
  650.                         if (NOT(IsListEmpty(&FoundList)))
  651.                            SaveFoundFiles();
  652.                         break;
  653.  
  654.                      case GD_AllGad:
  655.                         if (IsListEmpty(&DevList))
  656.                            break;
  657.  
  658.                         node = DevList.lh_Head;
  659.                         while (node->ln_Succ)
  660.                         {
  661.                            remnode = node->ln_Succ;
  662.                            Remove(node);
  663.                            AddTail(&SelDevList, node);
  664.                            node = remnode;
  665.                         }
  666.  
  667.                         InitListView(FindFileWnd,FindFileGadgets[GD_DeviceLV],
  668.                                      NULL,0);
  669.                         NewList(&DevList);
  670.  
  671.                         refreshdevlists();
  672.                         if (strlen(pat))
  673.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], TRUE);
  674.                         break;
  675.  
  676.                      case GD_NoneGad:
  677.                         if (IsListEmpty(&SelDevList))
  678.                            break;
  679.  
  680.                         node = SelDevList.lh_Head;
  681.                         while (node->ln_Succ)
  682.                         {
  683.                            remnode = node->ln_Succ;
  684.                            Remove(node);
  685.                            AddNodeSorted(&DevList, node);
  686.                            node = remnode;
  687.                         }
  688.  
  689.                         InitListView(FindFileWnd,FindFileGadgets[GD_SelDevLV],
  690.                                      NULL,0);
  691.                         NewList(&SelDevList);
  692.  
  693.                         refreshdevlists();
  694.                         EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], FALSE);
  695.                         break;
  696.  
  697.                      case GD_CaseCYGad:
  698.                         match_case = ((match_case == CASE) ? NO_CASE : CASE);
  699.                         if (strlen(pat) == 0)
  700.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], FALSE);
  701.                         else if ((*parse_func[match_case]) ((UBYTE *) pat,
  702.                                                             (UBYTE *) parsepat, 162) < 0)
  703.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], FALSE);
  704.                         else
  705.                            EnableGadget(FindFileWnd,FindFileGadgets[GD_StartStopGad], TRUE);
  706.                         break;
  707.  
  708.                      case GD_DirFileCYGad:
  709.                         match_type = code;
  710.                         break;
  711.                   }
  712.                   break;
  713.  
  714.                case IDCMP_VANILLAKEY:
  715.                   if (code == ESC)
  716.                   {
  717.                      if (NOT(IsListEmpty(&FoundList)) &&
  718.                          Question(FindFileWnd, "File list not empty!\n"
  719.                                   "Do you want to save it?", NO))
  720.                         SaveFoundFiles();
  721.  
  722.                      Flags.quit_ff = 1;
  723.                   }
  724.                   break;
  725.  
  726.                case IDCMP_CHANGEWINDOW:
  727.                case IDCMP_REFRESHWINDOW:
  728.                   if (NOT(FindFileWnd->Flags & WFLG_ZOOMED))
  729.                      RefreshRastPort(FindFileWnd,FindFileGadgets,gl, 4);
  730.  
  731.                   MakeWindowRefresh(FindFileWnd);
  732.                   break;
  733.  
  734.                case IDCMP_CLOSEWINDOW:
  735.                   if (NOT(IsListEmpty(&FoundList)) &&
  736.                       Question(FindFileWnd, "File list not empty!\n"
  737.                                "Do you want to save it?", NO))
  738.                      SaveFoundFiles();
  739.  
  740.                   Flags.quit_ff = 1;
  741.                   break;
  742.             }
  743.          }
  744.       }
  745.       while (NOT(Flags.quit_ff));
  746.  
  747.       FreeRemember(FILEKEY, TRUE);
  748.       FreeRemember(DEVKEY, TRUE);
  749.  
  750.       CloseASysWindow(&FindFileWnd, &FindFileGList, NULL);
  751.  
  752.       if (req)
  753.       {
  754.          UnlockWindow(req);
  755.          RefreshMainWindowPattern();
  756.          RefreshList(LastID);
  757.       }
  758.    }
  759.  
  760.    return;
  761. }
  762.  
  763. #define CMDFMT "%s DRIVE %s NAME \"%s\" %s %s %s %s"
  764.  
  765. static UBYTE fmtcmd[MAXWRITESIZE],
  766.       parts[7][MAXSTRLEN] =
  767. {
  768.    "SYS:System/Format", "DF0:", "Empty", "OFS", "NOINTL", "NOICONS", ""
  769. };
  770.  
  771. enum
  772. {
  773.    GD_FormatStrGad,
  774.    GD_SelFormatGad,
  775.    GD_DevLV,
  776.    GD_NameGad,
  777.    GD_IconsGad,
  778.    GD_FSCYGad,
  779.    GD_InterCYGad,
  780.    GD_FmtStrGad,
  781.    GD_FormatGad,
  782.    GD_QuickGad,
  783.    GD_CancelGad
  784. };
  785.  
  786. static struct Window *FormatDiskWnd = NULL;
  787. static struct Gadget *FormatDiskGList = NULL;
  788. static struct Gadget *FormatDiskGadgets[10];
  789. static UWORD FormatDiskLeft = 161;
  790. static UWORD FormatDiskTop = 49;
  791. static UWORD FormatDiskWidth = 297;
  792. static UWORD FormatDiskHeight = 116;
  793. static UBYTE *FormatDiskWdt = (UBYTE *) NAME " " VERSION " - Format Disk";
  794.  
  795. static UBYTE *IconsGad0Labels[]=
  796. {
  797.    (UBYTE *) "Icons",
  798.    (UBYTE *) "No Icons",
  799.    NULL};
  800.  
  801. static UBYTE *FSCYGad0Labels[]=
  802. {
  803.    (UBYTE *) "OFS",
  804.    (UBYTE *) "FFS",
  805.    NULL};
  806.  
  807. static UBYTE *InterCYGad0Labels[]=
  808. {
  809.    (UBYTE *) "No international",
  810.    (UBYTE *) "International",
  811.    NULL};
  812.  
  813. #define FormatDisk_CNT 10
  814.  
  815. static UWORD FormatDiskGTypes[] = {
  816.     STRING_KIND,
  817.     BUTTON_KIND,
  818.     LISTVIEW_KIND,
  819.     STRING_KIND,
  820.     CYCLE_KIND,
  821.     CYCLE_KIND,
  822.     CYCLE_KIND,
  823.     STRING_KIND,
  824.     BUTTON_KIND,
  825.     BUTTON_KIND
  826. };
  827.  
  828. static struct NewGadget FormatDiskNGad[] = {
  829.     68, 3, 145, 13, (UBYTE *)"Format", NULL, GD_FormatStrGad, PLACETEXT_LEFT, NULL, NULL,
  830.     216, 3, 73, 13, (UBYTE *)"Select", NULL, GD_SelFormatGad, PLACETEXT_IN, NULL, NULL,
  831.     8, 32, 73, 48, (UBYTE *)"Devices", NULL, GD_DevLV, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  832.     92, 32, 197, 13, (UBYTE *)"Disk label", NULL, GD_NameGad, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  833.     92, 50, 97, 13, NULL, NULL, GD_IconsGad, 0, NULL, NULL,
  834.     192, 50, 97, 13, NULL, NULL, GD_FSCYGad, 0, NULL, NULL,
  835.     92, 67, 197, 13, NULL, NULL, GD_InterCYGad, 0, NULL, NULL,
  836.     8, 85, 281, 13, NULL, NULL, GD_FmtStrGad, 0, NULL, NULL,
  837.     8, 100, 137, 13, (UBYTE *)"Format", NULL, GD_FormatGad, PLACETEXT_IN, NULL, NULL,
  838.     152, 100, 137, 13, (UBYTE *)"Quick", NULL, GD_QuickGad, PLACETEXT_IN, NULL, NULL
  839. };
  840.  
  841. static ULONG *FormatDiskGTags[] = {
  842.     (ULONG *)(GTST_String), (ULONG *)parts[0], (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  843.     (ULONG *)(TAG_DONE),
  844.     (ULONG *)(GTLV_ShowSelected), (ULONG *)NULL, (ULONG *)GTLV_Labels, (ULONG *)&DevList, (ULONG *)GTLV_Selected, (ULONG *)0, (ULONG *)GTLV_Top, (ULONG *)0, (ULONG *)(TAG_DONE),
  845.     (ULONG *)(GTST_String), (ULONG *)parts[2], (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  846.     (ULONG * )(GTCY_Labels), (ULONG *)&IconsGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  847.     (ULONG * )(GTCY_Labels), (ULONG *)&FSCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  848.     (ULONG * )(GTCY_Labels), (ULONG *)&InterCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  849.     (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)GTST_String, (ULONG *)fmtcmd, (ULONG *)(TAG_DONE),
  850.     (ULONG *)(TAG_DONE),
  851.     (ULONG *)(TAG_DONE)
  852. };
  853.  
  854.    /*
  855.     * OpenFormatDiskWindow() öffnet ein Window mit
  856.     * Kontrollelementen zu Aufruf des FORMAT-Befehls
  857.     */
  858. int
  859. OpenFormatDiskWindow( void )
  860. {
  861.     struct NewGadget    ng;
  862.     struct Gadget    *g;
  863.     UWORD        lc, tc;
  864.     UWORD        wleft = FormatDiskLeft, wtop = FormatDiskTop, ww, wh;
  865.    int gl[] = {GD_FormatStrGad,GD_DevLV,GD_NameGad,GD_FmtStrGad};
  866.  
  867.    DPOS;
  868.  
  869.     ComputeFont( Scr,FormatDiskWidth, FormatDiskHeight );
  870.  
  871.     ww = ComputeX( FormatDiskWidth );
  872.     wh = ComputeY( FormatDiskHeight );
  873.  
  874.     if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
  875.     if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;
  876.  
  877.    ww = compute((UWORD) (OffX + Scr->WBorRight), FontX, (int)FormatDiskWidth);
  878.    wh = compute((UWORD) (OffY + Scr->WBorBottom), FontY, (int)FormatDiskHeight);
  879.  
  880.    CenterWindow(Scr, &wtop, &wleft, ww, wh);
  881.  
  882.     if ( ! ( g = CreateContext( &FormatDiskGList )))
  883.         return( 1L );
  884.  
  885.     for( lc = 0, tc = 0; lc < FormatDisk_CNT; lc++ ) {
  886.  
  887.         CopyMem((char * )&FormatDiskNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  888.  
  889.         ng.ng_VisualInfo = VisualInfo;
  890.         ng.ng_TextAttr   = Font;
  891.         ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  892.         ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  893.         ng.ng_Width      = ComputeX( ng.ng_Width );
  894.         ng.ng_Height     = ComputeY( ng.ng_Height);
  895.  
  896.         FormatDiskGadgets[ lc ] = g = CreateGadgetA((ULONG)FormatDiskGTypes[ lc ], g, &ng, ( struct TagItem * )&FormatDiskGTags[ tc ] );
  897.  
  898.       makelabelvisible(FormatDiskGadgets[lc]);
  899.  
  900.         while( FormatDiskGTags[ tc ] ) tc += 2;
  901.         tc++;
  902.  
  903.         if ( NOT g )
  904.             return( 2L );
  905.     }
  906.  
  907.     if ( ! ( FormatDiskWnd = OpenWindowTags( NULL,
  908.                 WA_Left,    wleft,
  909.                 WA_Top,        wtop,
  910.                 WA_Width,    ww, /* + OffX + Scr->WBorRight,*/
  911.                 WA_Height,    wh, /* + OffY + Scr->WBorBottom,*/
  912.                 WA_IDCMP,    STRINGIDCMP|
  913.                         BUTTONIDCMP|
  914.                         LISTVIEWIDCMP|
  915.                         CYCLEIDCMP|
  916.                         IDCMP_CLOSEWINDOW|
  917.                         IDCMP_REFRESHWINDOW|
  918.                         IDCMP_VANILLAKEY,
  919.                 WA_Flags,    WFLG_DRAGBAR|
  920.                         WFLG_DEPTHGADGET|
  921.                         WFLG_CLOSEGADGET|
  922.                         WFLG_SMART_REFRESH|
  923.                         WFLG_ACTIVATE|
  924.                         WFLG_RMBTRAP,
  925.                 WA_Gadgets,    FormatDiskGList,
  926.                 WA_Title,    FormatDiskWdt,
  927.             WA_PubScreenFallBack,TRUE,
  928.             WA_PubScreen, Scr,
  929.                 TAG_DONE )))
  930.       return( 4L );
  931.  
  932.    RefreshRastPort(FormatDiskWnd,FormatDiskGadgets,gl, 4);
  933.  
  934.     GT_RefreshWindow( FormatDiskWnd, NULL );
  935.  
  936.     return( 0L );
  937. }
  938.  
  939.    /*
  940.     * FindDevices() sucht nach formatierbaren Devices im System
  941.     * und baut eine Liste mit deren Namen auf
  942.     */
  943. static void
  944. FindDevices(void)
  945. {
  946.    struct DosList *DosList;
  947.    struct DeviceNode *DevNode;
  948.    char  dev[PATHPARTWIDTH],
  949.          str[MAXFULLNAME];
  950.  
  951.    DosList = LockDosList(LDF_DEVICES | LDF_READ);
  952.  
  953.    while (DosList = NextDosEntry(DosList, LDF_DEVICES | LDF_READ))
  954.    {
  955.       DevNode = (struct DeviceNode *) DosList;
  956.       if ((DevNode->dn_Startup > 1000) &&
  957.           (DevNode->dn_Task || DevNode->dn_Handler || DevNode->dn_SegList))
  958.       {
  959.          strncpy(str, B2CStr(dev, DevNode->dn_Name),MAXFULLNAME-1);
  960.          strcat(str, ":");
  961.  
  962.          MakeDevEntry(&DevList, str);
  963.       }
  964.    }
  965.  
  966.    UnLockDosList(LDF_DEVICES | LDF_READ);
  967.  
  968.    return;
  969. }
  970.  
  971.    /*
  972.     * update() aktualisiert den Aufruf des Formatbefehls nach den
  973.     * Einstellungen des Kontrollfensters
  974.     */
  975. static void
  976. update(void)
  977. {
  978.    sprintf((char *)fmtcmd, CMDFMT, parts[0], parts[1], parts[2], parts[3],
  979.            parts[4], parts[5], parts[6]);
  980.  
  981.    GT_SetGadgetAttrs(FormatDiskGadgets[GD_FmtStrGad], FormatDiskWnd,
  982.                      NULL,
  983.                      GTST_String, fmtcmd,
  984.                      TAG_DONE);
  985.  
  986.    return;
  987. }
  988.  
  989.    /*
  990.     * SelFormatProgram() bietet einen Filerequester an, mit dem
  991.     * ein alternativer Format-Befehl ausgeführt werden kann
  992.     */
  993. static void
  994. SelFormatProgram(void)
  995. {
  996.    if (GetFile(FormatDiskWnd,"SYS:System/","Format","#?",
  997.                "Select Format program","Select"))
  998.       if (exist((char *)_fullpath))
  999.       {
  1000.          strncpy((char *)parts[0], (char *)_fullpath, MAXSTRLEN);
  1001.          update();
  1002.       }
  1003.       else
  1004.          ErrorHandle(FILE_ERR, READ_FAIL, NO_KILL);
  1005.  
  1006.    return;
  1007. }
  1008.  
  1009. extern UBYTE autocon[];
  1010.  
  1011.    /*
  1012.     * startformat() führt den zusammengesetzten Format-Befehl mit
  1013.     * der System()-Routine aus
  1014.     */
  1015. static void
  1016. startformat(void)
  1017. {
  1018.    struct TagItem stags[5];
  1019.    BPTR  fileptr;
  1020.  
  1021.    if (fileptr = Open(autocon, MODE_OLDFILE))
  1022.    {
  1023.       stags[0].ti_Tag = SYS_Input;
  1024.       stags[0].ti_Data = fileptr;
  1025.       stags[1].ti_Tag = SYS_Output;
  1026.       stags[1].ti_Data = NULL;
  1027.       stags[2].ti_Tag = SYS_Asynch;
  1028.       stags[2].ti_Data = FALSE;
  1029.       stags[3].ti_Tag = SYS_UserShell;
  1030.       stags[3].ti_Data = TRUE;
  1031.       stags[4].ti_Tag = TAG_DONE;
  1032.  
  1033.       if (Question(FormatDiskWnd, (char *)fmtcmd, YES))
  1034.          if (System(fmtcmd, stags) == -1L)
  1035.          {
  1036.             Close(fileptr);
  1037.             ErrorHandle(TASK_ERR, CREATE_FAIL, NO_KILL);
  1038.          }
  1039.    }
  1040.  
  1041.    return;
  1042. }
  1043.  
  1044.    /*
  1045.     * FormatDisk() bietet eine kleine Benutzeroberfläche an und
  1046.     * verarbeitet die Eingaben, mit denen der Aufruf des
  1047.     * Format-Befehls konfiguriert werden kann
  1048.     */
  1049. void
  1050. FormatDisk(void)
  1051. {
  1052.    register struct IntuiMessage *message;
  1053.    struct Node *clicknode;
  1054.    ULONG class,
  1055.          code;
  1056.    APTR  object;
  1057.    APTR  req = NULL;
  1058.    char *buff;
  1059.  
  1060.    DPOS;
  1061.  
  1062.    Flags.quit_fd = 0;
  1063.  
  1064.    NewList(&DevList);
  1065.  
  1066.    FindDevices();
  1067.  
  1068.    if (OpenASysWindow(OpenFormatDiskWindow,NO_KILL))
  1069.    {
  1070.       if (SysWnd)
  1071.          req = LockWindow(SysWnd);
  1072.  
  1073.       update();
  1074.  
  1075.       GT_SetGadgetAttrs(FormatDiskGadgets[GD_DevLV], FormatDiskWnd,
  1076.                         NULL,
  1077.                         GTLV_Labels, &DevList,
  1078.                         TAG_DONE);
  1079.       do
  1080.       {
  1081.          Wait(1L << FormatDiskWnd->UserPort->mp_SigBit);
  1082.  
  1083.          while ((message = (struct IntuiMessage *)
  1084.                  GT_GetIMsg(FormatDiskWnd->UserPort)) != NULL)
  1085.          {
  1086.             object = message->IAddress;
  1087.             class = message->Class;
  1088.             code = message->Code;
  1089.  
  1090.             GT_ReplyIMsg(message);
  1091.  
  1092.             switch (class)
  1093.             {
  1094.                case IDCMP_GADGETUP:
  1095.                   switch (((struct Gadget *) object)->GadgetID)
  1096.                   {
  1097.                      case GD_FormatStrGad:
  1098.                         buff = gadgetbuff(FormatDiskGadgets[GD_FormatStrGad]);
  1099.                         if (exist(buff))
  1100.                         {
  1101.                            strncpy((char *)parts[0], buff, MAXSTRLEN);
  1102.                            update();
  1103.                         }
  1104.                         else
  1105.                            ErrorHandle(FILE_ERR, READ_FAIL, NO_KILL);
  1106.                         break;
  1107.  
  1108.                      case GD_SelFormatGad:
  1109.                         SelFormatProgram();
  1110.                         break;
  1111.  
  1112.                      case GD_DevLV:
  1113.                         clicknode = GetNode(&DevList, code);
  1114.                         strncpy((char *)parts[1], clicknode->ln_Name,MAXSTRLEN);
  1115.                         update();
  1116.                         break;
  1117.  
  1118.                      case GD_NameGad:
  1119.                         strncpy((char *)parts[2],gadgetbuff(FormatDiskGadgets[GD_NameGad]),
  1120.                                 MAXSTRLEN);
  1121.                         update();
  1122.                         break;
  1123.  
  1124.                      case GD_IconsGad:
  1125.                         if (code == 0)
  1126.                            parts[5][0] = STRINGEND;
  1127.                         else
  1128.                            strcpy((char *)parts[5], "NOICONS");
  1129.  
  1130.                         update();
  1131.                         break;
  1132.  
  1133.                      case GD_FSCYGad:
  1134.                         strncpy((char *)parts[3], (char *)FSCYGad0Labels[code],
  1135.                                MAXSTRLEN);
  1136.                         update();
  1137.                         break;
  1138.  
  1139.                      case GD_InterCYGad:
  1140.                         strcpy((char *)parts[4], (code == 0) ? "NOINTL" : "INTL");
  1141.                         update();
  1142.                         break;
  1143.  
  1144.                      case GD_FmtStrGad:
  1145.                         strncpy((char *)fmtcmd,
  1146.                                gadgetbuff(FormatDiskGadgets[GD_FmtStrGad]),
  1147.                                MAXWRITESIZE);
  1148.                         break;
  1149.  
  1150.                      case GD_FormatGad:
  1151.                         parts[6][0] = STRINGEND;
  1152.                         update();
  1153.                         startformat();
  1154.                         break;
  1155.  
  1156.                      case GD_QuickGad:
  1157.                         strcpy((char *)parts[6], "QUICK");
  1158.                         update();
  1159.                         startformat();
  1160.                         break;
  1161.                   }
  1162.  
  1163.                   break;
  1164.  
  1165.                case IDCMP_VANILLAKEY:
  1166.                   if (code == '\33')
  1167.                      Flags.quit_fd = 1;
  1168.                   break;
  1169.  
  1170.                case IDCMP_REFRESHWINDOW:
  1171.                   MakeWindowRefresh(FormatDiskWnd);
  1172.                   break;
  1173.  
  1174.                case IDCMP_CLOSEWINDOW:
  1175.                   Flags.quit_fd = 1;
  1176.                   break;
  1177.             }
  1178.          }
  1179.       }
  1180.       while (NOT(Flags.quit_fd));
  1181.  
  1182.       FreeRemember(DEVKEY, TRUE);
  1183.  
  1184.       CloseASysWindow(&FormatDiskWnd, &FormatDiskGList, NULL);
  1185.  
  1186.       if (req)
  1187.       {
  1188.          UnlockWindow(req);
  1189.          RefreshMainWindowPattern();
  1190.          RefreshList(LastID);
  1191.       }
  1192.    }
  1193.  
  1194.    return;
  1195. }
  1196.