home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 2 / goldfish_vol2_cd1.bin / files / util / misc / rsys / src / rsysformatdisk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-21  |  10.5 KB  |  433 lines
  1. /*
  2. ***************************************************************************
  3. *
  4. * Datei:
  5. *    RSysFormatDisk.c
  6. *
  7. * Inhalt:
  8. *
  9. *      --- Globale Routinen ---
  10. *
  11. *    void FormatDisk ( void );
  12. *
  13. *      --- Lokale  Routinen ---
  14. *
  15. *    static int OpenFormatDiskWindow ( void );
  16. *    static void FindDevices ( void );
  17. *    static void SelFormatProgram ( void );
  18. *    static void startformat ( void );
  19. *    static void update ( void );
  20. *
  21. * Bemerkungen:
  22. *    Enthält die Schnittstelle zum AmigaOS-Format-Befehl.
  23. *
  24. * Erstellungsdatum:
  25. *    19-Jul-93    Rolf Böhme
  26. *
  27. * Änderungen:
  28. *    19-Jul-93    Rolf Böhme    Erstellung
  29. *
  30. ***************************************************************************
  31. */
  32.  
  33. #include "RSys.h"
  34.  
  35. static struct List DevList;
  36. extern struct Remember *DevKey;
  37.  
  38. static UBYTE fmtcmd[MAXWRITESIZE],
  39.         parts[7][MAXSTRLEN] =
  40. {
  41.     "SYS:System/Format", "DF0:", "Empty", "OFS", "NOINTL", "NOICONS", ""
  42. };
  43.  
  44. static struct Window *FormatDiskWnd = NULL;
  45. static struct Gadget *FormatDiskGList = NULL;
  46. static struct Gadget *FormatDiskGadgets[10];
  47. static UWORD FormatDiskLeft = 161;
  48. static UWORD FormatDiskTop = 49;
  49. static UWORD FormatDiskWidth = 297;
  50. static UWORD FormatDiskHeight = 116;
  51. static UBYTE *FormatDiskWdt = (UBYTE *) NAME " " VERSION " - Format Disk";
  52.  
  53. static UBYTE *IconsGad0Labels[]=
  54. {
  55.     (UBYTE *) "Icons",
  56.     (UBYTE *) "No Icons",
  57.     NULL};
  58.  
  59. static UBYTE *FSCYGad0Labels[]=
  60. {
  61.     (UBYTE *) "OFS",
  62.     (UBYTE *) "FFS",
  63.     NULL};
  64.  
  65. static UBYTE *InterCYGad0Labels[]=
  66. {
  67.     (UBYTE *) "No international",
  68.     (UBYTE *) "International",
  69.     NULL};
  70.  
  71. static UWORD FormatDiskGTypes[] = {
  72.     STRING_KIND,
  73.     BUTTON_KIND,
  74.     LISTVIEW_KIND,
  75.     STRING_KIND,
  76.     CYCLE_KIND,
  77.     CYCLE_KIND,
  78.     CYCLE_KIND,
  79.     STRING_KIND,
  80.     BUTTON_KIND,
  81.     BUTTON_KIND
  82. };
  83.  
  84. static struct NewGadget FormatDiskNGad[] = {
  85.     68, 3, 145, 13, (UBYTE *)"Format", NULL, GD_FormatStrGad, PLACETEXT_LEFT, NULL, NULL,
  86.     216, 3, 73, 13, (UBYTE *)"Select", NULL, GD_SelFormatGad, PLACETEXT_IN, NULL, NULL,
  87.     8, 32, 73, 48, (UBYTE *)"Devices", NULL, GD_DevLV, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  88.     92, 32, 197, 13, (UBYTE *)"Disk label", NULL, GD_NameGad, PLACETEXT_ABOVE|NG_HIGHLABEL, NULL, NULL,
  89.     92, 50, 97, 13, NULL, NULL, GD_IconsGad, 0, NULL, NULL,
  90.     192, 50, 97, 13, NULL, NULL, GD_FSCYGad, 0, NULL, NULL,
  91.     92, 67, 197, 13, NULL, NULL, GD_InterCYGad, 0, NULL, NULL,
  92.     8, 85, 281, 13, NULL, NULL, GD_FmtStrGad, 0, NULL, NULL,
  93.     8, 100, 137, 13, (UBYTE *)"Format", NULL, GD_FormatGad, PLACETEXT_IN, NULL, NULL,
  94.     152, 100, 137, 13, (UBYTE *)"Quick", NULL, GD_QuickGad, PLACETEXT_IN, NULL, NULL
  95. };
  96.  
  97. static ULONG *FormatDiskGTags[] = {
  98.     (ULONG *)(GTST_String), (ULONG *)parts[0], (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  99.     (ULONG *)(TAG_DONE),
  100.     (ULONG *)(GTLV_ShowSelected), (ULONG *)NULL, (ULONG *)GTLV_Labels, (ULONG *)&DevList, (ULONG *)GTLV_Selected, (ULONG *)0, (ULONG *)GTLV_Top, (ULONG *)0, (ULONG *)(TAG_DONE),
  101.     (ULONG *)(GTST_String), (ULONG *)parts[2], (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)(TAG_DONE),
  102.     (ULONG * )(GTCY_Labels), (ULONG *)&IconsGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  103.     (ULONG * )(GTCY_Labels), (ULONG *)&FSCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  104.     (ULONG * )(GTCY_Labels), (ULONG *)&InterCYGad0Labels[ 0 ], (ULONG *)(TAG_DONE),
  105.     (ULONG *)(GTST_MaxChars), (ULONG *)256, (ULONG *)GTST_String, (ULONG *)fmtcmd, (ULONG *)(TAG_DONE),
  106.     (ULONG *)(TAG_DONE),
  107.     (ULONG *)(TAG_DONE)
  108. };
  109.  
  110.     /*
  111.      * OpenFormatDiskWindow() öffnet ein Window mit
  112.      * Kontrollelementen zu Aufruf des FORMAT-Befehls
  113.      */
  114. static int
  115. OpenFormatDiskWindow( void )
  116. {
  117.     struct NewGadget    ng;
  118.     struct Gadget    *g;
  119.     UWORD        lc, tc;
  120.     UWORD        wleft = FormatDiskLeft, wtop = FormatDiskTop, ww, wh;
  121.     int gl[] = {GD_FormatStrGad - GD_FormatStrGad,
  122.                GD_DevLV - GD_FormatStrGad,
  123.                GD_NameGad - GD_FormatStrGad,
  124.                GD_FmtStrGad - GD_FormatStrGad};
  125.  
  126.     DPOS;
  127.  
  128.    AdjustWindowDimensions(Scr, FormatDiskLeft, FormatDiskTop, FormatDiskWidth, FormatDiskHeight,
  129.                                &wleft, &wtop, &ww, &wh);
  130.  
  131.     if ( ! ( g = CreateContext( &FormatDiskGList ))) return( 1L );
  132.  
  133.     for( lc = 0, tc = 0; lc < FormatDisk_CNT; lc++ ) 
  134.    {
  135.         CopyMem((char * )&FormatDiskNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  136.  
  137.         ng.ng_VisualInfo = VisualInfo;
  138.         ng.ng_TextAttr     = Font;
  139.         ng.ng_LeftEdge     = OffX + ComputeX( ng.ng_LeftEdge );
  140.         ng.ng_TopEdge     = OffY + ComputeY( ng.ng_TopEdge );
  141.         ng.ng_Width         = ComputeX( ng.ng_Width );
  142.         ng.ng_Height      = ComputeY( ng.ng_Height);
  143.  
  144.         FormatDiskGadgets[ lc ] = g = CreateGadgetA((ULONG)FormatDiskGTypes[ lc ], g, &ng, ( struct TagItem * )&FormatDiskGTags[ tc ] );
  145.  
  146.         makelabelvisible(FormatDiskGadgets[lc]);
  147.  
  148.         while( FormatDiskGTags[ tc ] ) tc += 2;
  149.  
  150.         tc++;
  151.  
  152.         if ( NOT g ) return( 2L );
  153.     }
  154.  
  155.     if ( ! ( FormatDiskWnd = OpenWindowTags( NULL,
  156.                 WA_Left,    wleft,
  157.                 WA_Top,        wtop,
  158.                 WA_Width,    ww,
  159.                 WA_Height,    wh,
  160.                 WA_IDCMP,    STRINGIDCMP|
  161.                                 BUTTONIDCMP|
  162.                                 LISTVIEWIDCMP|
  163.                                 CYCLEIDCMP|
  164.                                 IDCMP_CLOSEWINDOW|
  165.                                 IDCMP_REFRESHWINDOW|
  166.                                 IDCMP_VANILLAKEY,
  167.                 WA_Flags,    WFLG_DRAGBAR|
  168.                                 WFLG_DEPTHGADGET|
  169.                                 WFLG_CLOSEGADGET|
  170.                                 WFLG_SMART_REFRESH|
  171.                                 WFLG_ACTIVATE|
  172.                                 WFLG_RMBTRAP,
  173.                 WA_Title,    FormatDiskWdt,
  174.                 WA_PubScreenFallBack,TRUE,
  175.                 WA_PubScreen, Scr,
  176.                 TAG_DONE )))
  177.         return( 4L );
  178.  
  179.     RefreshRastPort(FormatDiskWnd,FormatDiskGadgets,gl, 4, FALSE, FormatDiskGList);
  180.  
  181.     return 0L;
  182. }
  183.  
  184.     /*
  185.      * FindDevices() sucht nach formatierbaren Devices im System
  186.      * und baut eine Liste mit deren Namen auf
  187.      */
  188. static void
  189. FindDevices(void)
  190. {
  191.     struct DosList *DosList;
  192.     struct DeviceNode *DevNode;
  193.     char    dev[PATHPARTWIDTH],
  194.             str[MAXFULLNAME];
  195.  
  196.     DosList = LockDosList(LDF_DEVICES | LDF_READ);
  197.  
  198.     while (DosList = NextDosEntry(DosList, LDF_DEVICES | LDF_READ))
  199.     {
  200.         DevNode = (struct DeviceNode *) DosList;
  201.         if ((DevNode->dn_Startup > 1000) && 
  202.           (DevNode->dn_Task || DevNode->dn_Handler || DevNode->dn_SegList))
  203.         {
  204.             strncpy(str, B2CStr(dev, DevNode->dn_Name),MAXFULLNAME-1);
  205.             strcat(str, ":");
  206.  
  207.             MakeDevEntry(&DevList, str);
  208.         }
  209.     }
  210.  
  211.     UnLockDosList(LDF_DEVICES | LDF_READ);
  212.  
  213.     return;
  214. }
  215.  
  216.     /*
  217.      * update() aktualisiert den Aufruf des Formatbefehls nach den
  218.      * Einstellungen des Kontrollfensters
  219.      */
  220. static void
  221. update(void)
  222. {
  223.     sprintf((char *)fmtcmd, CMDFMT, parts[0], parts[1], parts[2], parts[3],
  224.               parts[4], parts[5], parts[6]);
  225.  
  226.     GT_SetGadgetAttrs(FormatDiskGadgets[GD_FmtStrGad - GD_FormatStrGad], FormatDiskWnd,
  227.                             NULL,
  228.                             GTST_String, fmtcmd,
  229.                             TAG_DONE);
  230.  
  231.     return;
  232. }
  233.  
  234.     /*
  235.      * SelFormatProgram() bietet einen Filerequester an, mit dem
  236.      * ein alternativer Format-Befehl ausgeführt werden kann
  237.      */
  238. static void
  239. SelFormatProgram(void)
  240. {
  241.     if (GetFile(FormatDiskWnd,"SYS:System/","Format","#?", "Select Format program","Select"))
  242.         if (exist((char *)_fullpath))
  243.         {
  244.             strncpy((char *)parts[0], (char *)_fullpath, MAXSTRLEN);
  245.             update();
  246.         }
  247.         else ErrorHandle((char *)_fullpath, FILE_ERR, EXIST_FAIL, NO_KILL);
  248.  
  249.     return;
  250. }
  251.  
  252. extern UBYTE autocon[];
  253.  
  254.     /*
  255.      * startformat() führt den zusammengesetzten Format-Befehl mit
  256.      * der System()-Routine aus
  257.      */
  258. static void
  259. startformat(void)
  260. {
  261.     struct TagItem stags[5];
  262.     BPTR    fileptr;
  263.  
  264.     if (fileptr = Open(autocon, MODE_OLDFILE))
  265.     {
  266.         stags[0].ti_Tag = SYS_Input;
  267.         stags[0].ti_Data = fileptr;
  268.         stags[1].ti_Tag = SYS_Output;
  269.         stags[1].ti_Data = NULL;
  270.         stags[2].ti_Tag = SYS_Asynch;
  271.         stags[2].ti_Data = FALSE;
  272.         stags[3].ti_Tag = SYS_UserShell;
  273.         stags[3].ti_Data = TRUE;
  274.         stags[4].ti_Tag = TAG_DONE;
  275.  
  276.         if (Question(FormatDiskWnd, (char *)fmtcmd, YES))
  277.             if (System(fmtcmd, stags) == -1L)
  278.             {
  279.                 Close(fileptr);
  280.                 ErrorHandle((char *)fmtcmd, TASK_ERR, CREATE_FAIL, NO_KILL);
  281.             }
  282.     }
  283.  
  284.     return;
  285. }
  286.  
  287.     /*
  288.      * FormatDisk() bietet eine kleine Benutzeroberfläche an und
  289.      * verarbeitet die Eingaben, mit denen der Aufruf des
  290.      * Format-Befehls konfiguriert werden kann
  291.      */
  292. void
  293. FormatDisk(void)
  294. {
  295.     register struct IntuiMessage *message;
  296.     struct Node *clicknode;
  297.     ULONG class,
  298.             code;
  299.     APTR    object;
  300.     char *buff;
  301.    int ID;
  302.  
  303.     DPOS;
  304.  
  305.    HandleHelp(MN_FormatDisk);
  306.  
  307.     Flags.quit_fd = 0;
  308.  
  309.     NewList(&DevList);
  310.  
  311.     FindDevices();
  312.  
  313.     if (OpenASysWindow(OpenFormatDiskWindow,NO_KILL))
  314.     {
  315.       LockMainWindow(LOCK);
  316.  
  317.         update();
  318.  
  319.         GT_SetGadgetAttrs(FormatDiskGadgets[GD_DevLV - GD_FormatStrGad], FormatDiskWnd,
  320.                                 NULL,
  321.                                 GTLV_Labels, &DevList,
  322.                                 TAG_DONE);
  323.         do
  324.         {
  325.             Wait(1L << FormatDiskWnd->UserPort->mp_SigBit);
  326.  
  327.             while ((message = (struct IntuiMessage *)
  328.                       GT_GetIMsg(FormatDiskWnd->UserPort)) != NULL)
  329.             {
  330.                 object = message->IAddress;
  331.                 class = message->Class;
  332.                 code = message->Code;
  333.  
  334.                 GT_ReplyIMsg(message);
  335.  
  336.                 switch (class)
  337.                 {
  338.                     case IDCMP_GADGETUP:
  339.                   ID = ((struct Gadget *) object)->GadgetID;
  340.  
  341.                   HandleHelp((enum RSysNumbers)ID);
  342.  
  343.                         switch (ID)
  344.                         {
  345.                             case GD_FormatStrGad:
  346.                                 buff = gadgetbuff(FormatDiskGadgets[GD_FormatStrGad - GD_FormatStrGad]);
  347.                                 if (exist(buff))
  348.                                 {
  349.                                     strncpy((char *)parts[0], buff, MAXSTRLEN);
  350.                                     update();
  351.                                 }
  352.                                 else ErrorHandle(buff, FILE_ERR, EXIST_FAIL, NO_KILL);
  353.                                 break;
  354.  
  355.                             case GD_SelFormatGad:
  356.                                 SelFormatProgram();
  357.                                 break;
  358.  
  359.                             case GD_DevLV:
  360.                                 clicknode = GetNode(&DevList, code);
  361.                                 strncpy((char *)parts[1], clicknode->ln_Name,MAXSTRLEN);
  362.                                 update();
  363.                                 break;
  364.  
  365.                             case GD_NameGad:
  366.                                 strncpy((char *)parts[2],gadgetbuff(FormatDiskGadgets[GD_NameGad - GD_FormatStrGad]),
  367.                                           MAXSTRLEN);
  368.                                 update();
  369.                                 break;
  370.  
  371.                             case GD_IconsGad:
  372.                                 if (code == 0) parts[5][0] = STRINGEND;
  373.                                 else
  374.                                     strcpy((char *)parts[5], "NOICONS");
  375.                                 update();
  376.                                 break;
  377.  
  378.                             case GD_FSCYGad:
  379.                                 strncpy((char *)parts[3], (char *)FSCYGad0Labels[code], MAXSTRLEN);
  380.                                 update();
  381.                                 break;
  382.  
  383.                             case GD_InterCYGad:
  384.                                 strcpy((char *)parts[4], (code == 0) ? "NOINTL" : "INTL");
  385.                                 update();
  386.                                 break;
  387.  
  388.                             case GD_FmtStrGad:
  389.                                 strncpy((char *)fmtcmd,
  390.                                          gadgetbuff(FormatDiskGadgets[GD_FmtStrGad - GD_FormatStrGad]),
  391.                                          MAXWRITESIZE);
  392.                                 break;
  393.  
  394.                             case GD_FormatGad:
  395.                                 parts[6][0] = STRINGEND;
  396.                                 update();
  397.                                 startformat();
  398.                                 break;
  399.  
  400.                             case GD_QuickGad:
  401.                                 strcpy((char *)parts[6], "QUICK");
  402.                                 update();
  403.                                 startformat();
  404.                                 break;
  405.                         }
  406.  
  407.                         break;
  408.  
  409.                     case IDCMP_VANILLAKEY:
  410.                         if (code == '\33') Flags.quit_fd = 1;
  411.                         break;
  412.  
  413.                     case IDCMP_REFRESHWINDOW:
  414.                         MakeWindowRefresh(FormatDiskWnd);
  415.                         break;
  416.  
  417.                     case IDCMP_CLOSEWINDOW:
  418.                         Flags.quit_fd = 1;
  419.                         break;
  420.                 }
  421.             }
  422.         } while (NOT(Flags.quit_fd));
  423.  
  424.         FreeRemember(DEVKEY, TRUE);
  425.  
  426.         CloseASysWindow(&FormatDiskWnd, &FormatDiskGList, NULL);
  427.  
  428.       LockMainWindow(UNLOCK);
  429.     }
  430.  
  431.     return;
  432. }
  433.