workbench/system/BHFormat/gui.c

   1 /*
   2  *  Format -- disk formatting and file-system creation program
   3  *  Copyright (C) 1999 Ben Hutchings <womble@zzumbouk.demon.co.uk>
   4  *  Copyright (C) 2008 Pavel Fedin <sonic_amiga@rambler.ru>
   5
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /*
  22  *  Layout of the main window of version 40 in English is:
  23  *
  24  *  +-------------------------------------------------------------+
  25  *  | Format - <device>                                           |
  26  *  +-------------------------------------------------------------+
  27  *  |    Current Information: Device '<device>'                   |
  28  *  |                         Volume '<volume>'                   |
  29  *  |                         <size> capacity <usage>% used       |
  30  *  |                          _________________________________  |
  31  *  |        New Volume Name: |Empty____________________________| |
  32  *  |                          __                                 |
  33  *  |           Put Trashcan: |./|                                |
  34  *  |                          __                                 |
  35  *  |       Fast File System: |__|                                |
  36  *  |                          __                                 |
  37  *  |     International Mode: |__|                                |
  38  *  |                          __                                 |
  39  *  |        Directory Cache: |__|                                |
  40  *  |                                                             |
  41  *  | +-----------------+ +-----------------+ +-----------------+ |
  42  *  | |      Format     | |   Quick Format  | |      Cancel     | |
  43  *  | +-----------------+ +-----------------+ +-----------------+ |
  44  *  +-------------------------------------------------------------+
  45  *
  46  *  For ID_NOT_REALLY_DOS and ID_UNREADABLE_DISK volumes, the information
  47  *  takes the format:
  48  *      Device '<device>'
  49  *      <size> capacity
  50  *
  51  *  For non-native file-systems, the lower three checkboxes are not shown.
  52  *
  53  *  <size> is the whole number of kilobytes (units of 2^10 bytes)
  54  *  followed by `K', if this number is less than or equal to 9999;
  55  *  otherwise the whole number of megabytes (units of 2^20 bytes).
  56  *
  57  *  The progress window has this layout:
  58  *
  59  *  +-----------------------------------------------------------------------+
  60  *  | Format - <device>                                                     |
  61  *  +-----------------------------------------------------------------------+
  62  *  |                                                                       |
  63  *  |                           Formatting disk...                          |
  64  *  | +-------------------------------------------------------------------+ |
  65  *  | |                                                                   | |
  66  *  | +----------------+----------------+----------------+----------------+ |
  67  *  | 0%                               50%                             100% |
  68  *  |                                                                       |
  69  *  |                         +--------------------+                        |
  70  *  |                         |        Stop        |                        |
  71  *  |                         +--------------------+                        |
  72  *  +-----------------------------------------------------------------------+
  73  *
  74  *  The contents of this window are replaced by the text `Initializing
  75  *  disk...' for the file-system creation and trashcan creation stages.
  76  */
  77
  78 #define MUIMASTER_YES_INLINE_STDARG
  79 #include <libraries/mui.h>
  80 #include <proto/muimaster.h>
  81
  82 #include <dos/dosextens.h>
  83 #include <dos/filehandler.h>
  84 #include <intuition/intuition.h>
  85 #include <stdarg.h>
  86 #include <workbench/startup.h>
  87 #include <proto/dos.h>
  88 #include <proto/exec.h>
  89 #include <proto/gadtools.h>
  90 #include <proto/graphics.h>
  91 #include <proto/intuition.h>
  92
  93 #include <string.h>
  94
  95 #include "format.h"
  96 #include "locale.h"
  97
  98 static char szCapacityInfo[5+1+8+2+2+2+4+1];
  99 static Object *app, *mainwin, *formatwin, *chk_trash, *chk_intl, *chk_ffs, *chk_cache;
 100 static Object *txt_action, *str_volume, *gauge;
 101 static struct DosList * pdlVolume = 0;
 102 static struct Hook btn_format_hook;
 103 static struct Hook list_consfunc_hook;
 104 static struct Hook list_desfunc_hook;
 105 static struct Hook list_dispfunc_hook;
 106
 107 static void message(CONST_STRPTR s);
 108
 109 struct SFormatEntry
 110 {
 111     TEXT deviceName[32];
 112     TEXT volumeName[32];
 113     TEXT capacityInfo[64];
 114 };
 115
 116 AROS_UFH3S(IPTR, consfunc,
 117     AROS_UFHA(struct Hook *, h, A0),
 118         AROS_UFHA(IPTR*, pool, A2),
 119         AROS_UFHA(struct SFormatEntry *, entry,A1))
 120 {
 121     AROS_USERFUNC_INIT
 122
 123     int size = sizeof(struct SFormatEntry);
 124
 125     struct SFormatEntry *new = AllocPooled(pool, size);
 126
 127     if (new) memcpy(new, entry, size);
 128
 129     return (IPTR)new;
 130
 131     AROS_USERFUNC_EXIT
 132 }
 133
 134 AROS_UFH3S(void, desfunc,
 135     AROS_UFHA(struct Hook *, h, A0),
 136         AROS_UFHA(IPTR*, pool, A2),
 137         AROS_UFHA(struct SFormatEntry *, entry,A1))
 138 {
 139     AROS_USERFUNC_INIT
 140
 141     FreePooled(pool, entry, sizeof(struct SFormatEntry));
 142
 143     AROS_USERFUNC_EXIT
 144 }
 145
 146 AROS_UFH3S(LONG, dispfunc,
 147     AROS_UFHA(struct Hook *, h, A0),
 148         AROS_UFHA(char **, array, A2),
 149         AROS_UFHA(struct SFormatEntry *, entry,A1))
 150 {
 151     AROS_USERFUNC_INIT
 152
 153     static char s[128];
 154
 155     strcpy(s, "(");
 156     if (strlen(entry->volumeName))
 157     {
 158         strcat(s, entry->volumeName);
 159         strcat(s, ", ");
 160     }
 161     strcat(s, entry->capacityInfo);
 162     strcat(s, ")");
 163
 164     *array++ = entry->deviceName;
 165     *array = s;
 166
 167     return 0;
 168
 169     AROS_USERFUNC_EXIT
 170 }
 171
 172 BOOL ObjectTypeOk(struct DosList* device)
 173 {
 174     struct FileSysStartupMsg *pfssm;
 175     struct DosEnvec *pdenDevice;
 176
 177     if( (pfssm = (struct FileSysStartupMsg *)
 178          BADDR(device->dol_misc.dol_handler.dol_Startup)) == 0
 179         || TypeOfMem(pfssm) == 0
 180         || pfssm->fssm_Device == 0
 181         || (pdenDevice = (struct DosEnvec *)BADDR(pfssm->fssm_Environ)) == 0
 182         || TypeOfMem(pdenDevice) == 0
 183         || pdenDevice->de_TableSize < DE_DOSTYPE
 184         /* Check that parameters that should always be 0, are */
 185         || pdenDevice->de_SecOrg != 0
 186         || pdenDevice->de_Interleave != 0 )
 187     {
 188         /* error object wrong type */
 189                 return FALSE;
 190     }
 191
 192     ULLONG cbyTrack = (ULLONG)pdenDevice->de_BlocksPerTrack * (ULLONG)(pdenDevice->de_SizeBlock * sizeof(LONG));
 193     ULLONG cbyCylinder = cbyTrack * pdenDevice->de_Surfaces;
 194
 195     ibyStart = pdenDevice->de_LowCyl * cbyCylinder;
 196     ibyEnd = (pdenDevice->de_HighCyl + 1) * cbyCylinder;
 197
 198     return TRUE;
 199 }
 200
 201 void ComputeCapacity(struct DosList *pdlVolume, struct InfoData *pInfoData)
 202 {
 203         /* The units of the size are initially bytes, but we shift the
 204            number until the units are kilobytes, megabytes or
 205            something larger and the number of units has at most 4
 206            digits. */
 207         ULLONG cUnits;
 208         /* The unit symbols go up to exabytes, since the maximum
 209            possible disk size is 2^64 bytes = 16 exabytes. */
 210         const char * pchUnitSymbol = _(MSG_UNITS);
 211
 212         D(Printf("Calculating capacity info...\n"));
 213         cUnits = ibyEnd - ibyStart;
 214         while( (cUnits >>= 10) > 9999 )
 215             ++pchUnitSymbol;
 216
 217         if(pdlVolume && pInfoData)
 218             RawDoFmtSz( szCapacityInfo, _(MSG_CAPACITY_USED),
 219                         (ULONG)cUnits, (ULONG)*pchUnitSymbol,
 220                         /* Calculate percentage used, to nearest point. */
 221                         (ULONG)(((ULLONG)pInfoData->id_NumBlocksUsed*100ULL
 222                                  + pInfoData->id_NumBlocks/2) / pInfoData->id_NumBlocks) );
 223         else
 224             RawDoFmtSz( szCapacityInfo, "%lu%lc capacity",
 225                         (ULONG)cUnits, (ULONG)*pchUnitSymbol );
 226         D(Printf("Done: %s\n", szCapacityInfo));
 227 }
 228
 229 void VolumesToList(Object* listObject)
 230 {
 231     ULONG flags = LDF_READ | LDF_DEVICES | LDF_VOLUMES;
 232     struct DosList *adl, *device, *volume;
 233
 234     adl = device = AttemptLockDosList(flags);
 235
 236     if (adl == NULL) return;
 237
 238     while((device = NextDosEntry(device, flags - LDF_VOLUMES)) != NULL)
 239     {
 240         TEXT name[128];
 241         strcpy(name, device->dol_Name);
 242         strcat(name, ":");
 243
 244         /* exclude RAM, NIL, RAW, CON, ... */
 245         if (!ObjectTypeOk(device)) continue;
 246
 247         /* floppy, cdrom and unformatted disks can't be locked */
 248         BPTR lock = Lock(name, SHARED_LOCK);
 249         BOOL addDevice = TRUE;
 250         struct InfoData *pInfoData = NULL;
 251
 252         if (lock)
 253         {
 254             struct InfoData infoData;
 255
 256             /* XPIPE and PIPEFS fails here */
 257             if (Info(lock, &infoData))
 258             {
 259                 pInfoData = &infoData;
 260             }
 261             else addDevice = FALSE;
 262
 263             UnLock(lock);
 264         }
 265
 266         if (addDevice)
 267         {
 268             struct SFormatEntry entry;
 269             strcpy(entry.deviceName, device->dol_Name);
 270             volume = adl;
 271
 272             do
 273             {
 274                 if ((volume = NextDosEntry(volume, LDF_VOLUMES)) == 0) break;
 275             } while((volume->dol_Ext.dol_AROS.dol_Device != device->dol_Ext.dol_AROS.dol_Device) ||
 276                 (volume->dol_Ext.dol_AROS.dol_Unit != device->dol_Ext.dol_AROS.dol_Unit));
 277
 278             if (volume) strcpy(entry.volumeName, volume->dol_Name);
 279             else strcpy(entry.volumeName, "");
 280
 281             ComputeCapacity(volume, pInfoData);
 282             strcpy(entry.capacityInfo, szCapacityInfo);
 283
 284             DoMethod(listObject, MUIM_List_InsertSingle, &entry,
 285                 MUIV_List_Insert_Top);
 286         }
 287     }
 288
 289     UnLockDosList(flags);
 290 }
 291
 292 struct SFormatEntry* SelectDevice(void)
 293 {
 294     Object *app, *wnd, *list, *ok, *cancel;
 295
 296     list_consfunc_hook.h_Entry = (HOOKFUNC)consfunc;
 297     list_desfunc_hook.h_Entry = (HOOKFUNC)desfunc;
 298     list_dispfunc_hook.h_Entry = (HOOKFUNC)dispfunc;
 299
 300     app = (Object *)ApplicationObject,
 301         SubWindow, (IPTR)(wnd = (Object *)WindowObject,
 302             MUIA_Window_CloseGadget, (IPTR)FALSE,
 303             MUIA_Window_Title, (IPTR)_(MSG_APPLICATION_TITLE),
 304             WindowContents, (IPTR)(VGroup,
 305                 Child, (IPTR)(TextObject,
 306                     MUIA_Text_Contents, (IPTR)"Select Device To Format",
 307                 End),
 308                 Child, (IPTR)(list = (Object *)ListviewObject,
 309                     MUIA_Listview_List, ListObject,
 310                         InputListFrame,
 311                         MUIA_List_ConstructHook, (IPTR)&list_consfunc_hook,
 312                         MUIA_List_DestructHook, (IPTR)&list_desfunc_hook,
 313                         MUIA_List_DisplayHook, (IPTR)&list_dispfunc_hook,
 314                         MUIA_List_Format, (IPTR)",",
 315                         MUIA_List_AdjustWidth, (IPTR)TRUE,
 316                     End,
 317                 End),
 318                 Child, (IPTR)(HGroup,
 319                     Child, (IPTR)(ok = SimpleButton(_(MSG_OK))),
 320                     Child, (IPTR)RectangleObject, End,
 321                     Child, (IPTR)(cancel = SimpleButton(_(MSG_CANCEL))),
 322                 End),
 323             End),
 324         End),
 325     End;
 326
 327     if(app == NULL) return;
 328
 329     VolumesToList(list);
 330
 331     DoMethod(list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
 332         ok , 3, MUIM_Set, MUIA_Disabled, FALSE);
 333     DoMethod(ok, MUIM_Notify, MUIA_Pressed, FALSE,
 334         app, 2, MUIM_Application_ReturnID, (IPTR)ok);
 335     DoMethod(cancel, MUIM_Notify, MUIA_Pressed, FALSE,
 336         app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 337
 338     set(ok, MUIA_Disabled, TRUE);
 339     set(wnd, MUIA_Window_Open, TRUE);
 340
 341     ULONG sigs = 0;
 342
 343     // Main loop
 344     struct SFormatEntry* selectedEntry = NULL;
 345     LONG returnId;
 346     while((returnId = (LONG)DoMethod(app, MUIM_Application_NewInput, (IPTR)&sigs))
 347         != MUIV_Application_ReturnID_Quit)
 348     {
 349         if (sigs)
 350         {
 351             if ((Object*) returnId == ok)
 352             {
 353                 IPTR active = XGET(list, MUIA_List_Active);
 354                 struct SFormatEntry *entry;
 355                 DoMethod(list, MUIM_List_GetEntry, active, &entry);
 356                 selectedEntry = AllocMem(sizeof(struct SFormatEntry), 0L);
 357                 if (selectedEntry)
 358                     memcpy(selectedEntry, entry, sizeof(struct SFormatEntry));
 359                 break;
 360             }
 361
 362             sigs = Wait(sigs | SIGBREAKF_CTRL_C);
 363
 364             if (sigs & SIGBREAKF_CTRL_C)
 365                 break;
 366         }
 367     }
 368
 369     MUI_DisposeObject(app);
 370
 371     return selectedEntry;
 372 }
 373
 374 AROS_UFH3S(void, btn_format_function,
 375     AROS_UFHA(struct Hook *, h, A0),
 376     AROS_UFHA(Object *, object, A2),
 377     AROS_UFHA(IPTR *, msg, A1))
 378 {
 379     AROS_USERFUNC_INIT
 380
 381     BOOL bDoFormat = *msg;
 382     BOOL bMakeTrashcan, bFFS, bIntl;
 383     BOOL bDirCache = FALSE;
 384     LONG rc = FALSE;
 385
 386     D(Printf("Full format? %d\n", bDoFormat));
 387
 388     if(!bSetSzDosDeviceFromSz(szDosDevice))
 389         goto cleanup;
 390
 391     /* TODO: set volume name same as old one if name is null string */
 392     if( !bSetSzVolumeFromSz( (char *)XGET(str_volume, MUIA_String_Contents) ) )
 393     {
 394         goto cleanup;
 395     }
 396
 397     bMakeTrashcan = XGET(chk_trash, MUIA_Selected);
 398     bFFS = XGET(chk_ffs, MUIA_Selected);
 399     bIntl = XGET(chk_intl, MUIA_Selected);
 400     bDirCache = XGET(chk_cache, MUIA_Selected);
 401 #ifdef __AROS__
 402     bDirCache = FALSE;
 403 #endif
 404
 405     if(bDoFormat)
 406     {
 407         set(txt_action, MUIA_Text_Contents, _(MSG_GUI_FORMATTING) );
 408     }
 409     else
 410     {
 411         set(txt_action, MUIA_Text_Contents, _(MSG_GUI_INITIALIZING) );
 412     }
 413
 414     set(mainwin, MUIA_Window_Open, FALSE);
 415     set(formatwin, MUIA_Window_Open, TRUE);
 416
 417     {
 418         char szVolumeId[11 + MAX_FS_NAME_LEN];
 419         if(pdlVolume)
 420             RawDoFmtSz( szVolumeId, "%b", pdlVolume->dol_Name );
 421         else
 422             RawDoFmtSz( szVolumeId, _(MSG_IN_DEVICE), szDosDevice );
 423         if( MUI_Request ( app, formatwin, 0,
 424                             _(MSG_FORMAT_REQUEST_TITLE), _(MSG_FORMAT_REQUEST_GADGETS),
 425                             _(MSG_FORMAT_REQUEST_TEXT),
 426                             szVolumeId, szCapacityInfo) != 1)
 427             goto cleanup;
 428     }
 429
 430     BOOL formatOk = TRUE;
 431     if(bDoFormat)
 432     {
 433         ULONG icyl, sigs;
 434         if(!bGetExecDevice(TRUE))
 435             goto cleanup;
 436         D(PutStr("GetExecDevice done\n"));
 437         set(gauge, MUIA_Gauge_Max, HighCyl-LowCyl);
 438         for( icyl = LowCyl; icyl <= HighCyl; ++icyl )
 439         {
 440             DoMethod(app, MUIM_Application_Input, (IPTR)&sigs);
 441             /* interrupted by user? */
 442             if(XGET(formatwin, MUIA_UserData) == 1)
 443             {
 444                 formatOk = FALSE;
 445                 break;
 446             }
 447             if(!bFormatCylinder(icyl) || !bVerifyCylinder(icyl))
 448             {
 449                 formatOk = FALSE;
 450                 break;
 451             }
 452             set(gauge, MUIA_Gauge_Current, icyl-LowCyl);
 453         }
 454         FreeExecDevice();
 455         D(PutStr("FreeExecDevice done\n"));
 456     }
 457
 458     if(formatOk)
 459         if( bMakeFileSys( bFFS, !bFFS, bIntl, !bIntl, bDirCache, !bDirCache )
 460             && (!bMakeTrashcan || bMakeFiles(FALSE)) )
 461             rc = RETURN_OK;
 462
 463 cleanup:
 464     DoMethod(app, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 465
 466     AROS_USERFUNC_EXIT
 467 }
 468
 469 int rcGuiMain(void)
 470 {
 471     static char szTitle[6+3+30+1];
 472     char szVolumeInfo[6+2+MAX_FS_NAME_LEN+2];
 473     char szDeviceInfo[6+2+MAX_FS_NAME_LEN+2];
 474     char szVolumeName[108];
 475     struct DosList *pdlDevice = NULL;
 476     szVolumeInfo[0] = '\0';
 477 #ifdef AROS_FAKE_LOCK
 478     char volName[108];
 479 #else
 480     struct FileLock * pflVolume = 0;
 481 #endif
 482     static struct InfoData dinf __attribute__((aligned (4)));
 483     LONG rc = RETURN_FAIL;
 484
 485 #if DEBUG
 486     BPTR bpfhStdErr =
 487         Open("CON:0/50/640/400/Format Debug Output/CLOSE/WAIT",MODE_READWRITE);
 488     BPTR OldInput = SelectInput(bpfhStdErr);
 489     BPTR OldOutput = SelectOutput(bpfhStdErr);
 490 #endif
 491
 492     if( _WBenchMsg->sm_NumArgs > 1 )
 493     {
 494         struct DosList *pdlList;
 495
 496         if( _WBenchMsg->sm_ArgList[1].wa_Lock == 0 )
 497         {
 498             D(Printf("Object specified by name: %s\n", _WBenchMsg->sm_ArgList[1].wa_Name);)
 499             /* it's a device */
 500             if( !bSetSzDosDeviceFromSz(_WBenchMsg->sm_ArgList[1].wa_Name) ) {
 501                 D(Printf("Bad device name wrom Workbench: %s\n", _WBenchMsg->sm_ArgList[1].wa_Name));
 502                 /* Workbench is playing silly buggers */
 503                 goto cleanup;
 504             }
 505         }
 506         else if( _WBenchMsg->sm_ArgList[1].wa_Name[0] == 0 )
 507         {
 508             /* it's a volume */
 509
 510             D(Printf("Object specified by lock\n"));
 511             /* make sure it's mounted before looking for its device */
 512             if( !Info( _WBenchMsg->sm_ArgList[1].wa_Lock, &dinf ) )
 513             {
 514                 ReportErrSz( ertFailure, 0, 0 );
 515                 goto cleanup;
 516             }
 517 #ifdef AROS_FAKE_LOCK
 518             if (NameFromLock(_WBenchMsg->sm_ArgList[1].wa_Lock, volName, sizeof(volName)))
 519             {
 520                 D(Printf("Volume name: %s\n", volName));
 521                 volName[strlen(volName)-1] = '\0';
 522                 pdlList = LockDosList( LDF_DEVICES | LDF_VOLUMES | LDF_READ );
 523                 pdlVolume = FindDosEntry(pdlList, volName, LDF_VOLUMES);
 524                 if (pdlVolume)
 525                 {
 526                     D(Printf("Looking for device = 0x%08lX Unit = 0x%08lX\n",
 527                              pdlVolume->dol_Ext.dol_AROS.dol_Device,
 528                              pdlVolume->dol_Ext.dol_AROS.dol_Unit));
 529                     pdlDevice = pdlList;
 530                     do
 531                     {
 532                         if ((pdlDevice = NextDosEntry(pdlDevice, LDF_DEVICES)) == 0)
 533                             break;
 534                         D(Printf("Checking device %s:\n", pdlDevice->dol_Ext.dol_AROS.dol_DevName);)
 535                         D(Printf("Device = 0x%08lX Unit = 0x%08lX\n", pdlDevice->dol_Ext.dol_AROS.dol_Device,
 536                                  pdlDevice->dol_Ext.dol_AROS.dol_Unit);)
 537                     }
 538                     while((pdlDevice->dol_Ext.dol_AROS.dol_Device != pdlVolume->dol_Ext.dol_AROS.dol_Device) ||
 539                           (pdlDevice->dol_Ext.dol_AROS.dol_Unit != pdlVolume->dol_Ext.dol_AROS.dol_Unit));
 540                 }
 541             }
 542 #else
 543             pflVolume =
 544                 (struct FileLock *)BADDR(_WBenchMsg->sm_ArgList[1].wa_Lock);
 545             pdlVolume = (struct DosList *)BADDR(pflVolume->fl_Volume);
 546             pdlList = LockDosList( LDF_DEVICES | LDF_READ );
 547             pdlDevice = pdlList;
 548             do
 549             {
 550                 if ((pdlDevice = NextDosEntry(pdlDevice, LDF_DEVICES)) == 0)
 551                     break;
 552             }
 553             while( pdlDevice->dol_Task != pflVolume->fl_Task );
 554 #endif
 555             if (!pdlDevice)
 556             {
 557                 ReportErrSz( ertFailure, ERROR_DEVICE_NOT_MOUNTED, 0 );
 558                 goto cleanup;
 559             }
 560             RawDoFmtSz( szDosDevice, "%b", pdlDevice->dol_Name );
 561             pchDosDeviceColon = szDosDevice + strlen(szDosDevice);
 562             *(pchDosDeviceColon+1) = 0;
 563         }
 564         else
 565         {
 566             ReportErrSz( ertFailure, ERROR_OBJECT_WRONG_TYPE, 0 );
 567             goto cleanup;
 568         }
 569
 570         ComputeCapacity(pdlVolume, &dinf );
 571
 572         if (pdlVolume)
 573             strcpy(szVolumeName, pdlVolume->dol_Name);
 574     }
 575     else if ( _WBenchMsg->sm_NumArgs == 1 )
 576     {
 577         /* message(_(MSG_ERROR_WANDERER) ); */
 578         struct SFormatEntry* entry = SelectDevice();
 579         if (!entry)
 580             goto cleanup;
 581         strcpy(szDosDevice, entry->deviceName);
 582         strcat(szDosDevice, ":");
 583         strcpy(szVolumeName, entry->volumeName);
 584         strcpy(szCapacityInfo, entry->capacityInfo);
 585         FreeMem(entry, sizeof(struct SFormatEntry));
 586     }
 587
 588 #ifdef AROS_FAKE_LOCK
 589     if (!bGetDosDevice(pdlDevice, LDF_DEVICES|LDF_VOLUMES|LDF_READ))
 590 #else
 591     if (!bGetDosDevice(pdlDevice, LDF_DEVICES|LDF_READ))
 592 #endif
 593         goto cleanup;
 594
 595     RawDoFmtSz( szTitle, _(MSG_WINDOW_TITLE), szDosDevice );
 596     D(Printf("Setting window title to '%s'\n", szTitle));
 597
 598     {
 599         Object *btn_format, *btn_qformat, *btn_cancel, *btn_stop;
 600
 601         btn_format_hook.h_Entry = (HOOKFUNC)btn_format_function;
 602
 603         RawDoFmtSz( szDeviceInfo, _(MSG_DEVICE), szDosDevice );
 604         RawDoFmtSz( szVolumeInfo, _(MSG_VOLUME), szVolumeName );
 605
 606         D(Printf("Creating GUI...\n"));
 607
 608         app = (Object *)ApplicationObject,
 609             MUIA_Application_Title, __(MSG_APPLICATION_TITLE),
 610             MUIA_Application_Version, (IPTR)szVersion,
 611             MUIA_Application_Description, __(MSG_DESCRIPTION),
 612             MUIA_Application_Copyright, __(MSG_COPYRIGHT),
 613             MUIA_Application_Author, __(MSG_AUTHOR),
 614             MUIA_Application_Base, (IPTR)"FORMAT",
 615             MUIA_Application_SingleTask, FALSE,
 616             SubWindow, (IPTR)(mainwin = (Object *)WindowObject,
 617                 MUIA_Window_ID, MAKE_ID('F','R','M','1'),
 618                 MUIA_Window_Title, (IPTR)szTitle,
 619                 WindowContents, (IPTR)(VGroup,
 620                     Child, (IPTR)(ColGroup(2),
 621                         Child, (IPTR)Label2( _(MSG_LABEL_CURRENT_INFORMATION) ),
 622                         Child, (IPTR)(TextObject,
 623                             (IPTR)TextFrame,
 624                             MUIA_Text_Contents, (IPTR)szDeviceInfo,
 625                         End),
 626                         Child, (IPTR)Label2(""),
 627                         Child, (IPTR)(TextObject,
 628                             TextFrame,
 629                             MUIA_Text_Contents, (IPTR)szVolumeInfo,
 630                         End),
 631                         Child, (IPTR)Label2(""),
 632                         Child, (IPTR)(TextObject,
 633                             TextFrame,
 634                             MUIA_Text_Contents, (IPTR)szCapacityInfo,
 635                         End),
 636                         Child, (IPTR)Label2( _(MSG_LABEL_NEW_VOLUME_NAME) ),
 637                         Child, (IPTR)(str_volume = (Object *)StringObject,
 638                             StringFrame,
 639                             MUIA_String_Contents, __(MSG_DEFAULT_VOLUME_NAME),
 640                             MUIA_String_MaxLen, MAX_FS_NAME_LEN,
 641                         End),
 642                         Child, (IPTR)Label2( _(MSG_LABEL_PUT_TRASHCAN) ),
 643                         Child, (IPTR)(chk_trash = MUI_MakeObject(MUIO_Checkmark, NULL)),
 644                         Child, (IPTR)Label2( _(MSG_LABEL_FFS) ),
 645                         Child, (IPTR)(chk_ffs = MUI_MakeObject(MUIO_Checkmark, NULL)),
 646                         Child, (IPTR)Label2( _(MSG_LABEL_INTL)),
 647                         Child, (IPTR)(chk_intl = MUI_MakeObject(MUIO_Checkmark, NULL)),
 648                         Child, (IPTR)Label2( _(MSG_LABEL_CACHE) ),
 649                         Child, (IPTR)(chk_cache = MUI_MakeObject(MUIO_Checkmark, NULL)),
 650                     End), /* ColGroup */
 651                     Child, (IPTR) (RectangleObject,
 652                         MUIA_Rectangle_HBar, TRUE,
 653                         MUIA_FixHeight,      2,
 654                     End),
 655                     Child, (IPTR)(HGroup,
 656                         Child, (IPTR)(btn_format  = ImageButton( _(MSG_BTN_FORMAT) , "THEME:Images/Gadgets/Prefs/Save")),
 657                         Child, (IPTR)(btn_qformat = ImageButton( _(MSG_BTN_QFORMAT), "THEME:Images/Gadgets/Prefs/Save")),
 658                         Child, (IPTR)(btn_cancel  = ImageButton( _(MSG_BTN_CANCEL) , "THEME:Images/Gadgets/Prefs/Cancel")),
 659                     End), /* HGroup */
 660                 End), /* VGroup */
 661             End), /* Window */
 662             SubWindow, (IPTR)(formatwin = (Object *)WindowObject,
 663                 MUIA_Window_ID, MAKE_ID('F','R','M','2'),
 664                 MUIA_Window_Title, (IPTR)szTitle,
 665                 MUIA_Window_CloseGadget, (IPTR)FALSE,
 666                 WindowContents, (IPTR)(VGroup,
 667                     Child, (IPTR)(txt_action = (Object *)TextObject,
 668                         TextFrame,
 669                     End),
 670                     Child, (IPTR)(gauge = (Object *)GaugeObject,
 671                         GaugeFrame,
 672                         MUIA_Gauge_Horiz, (IPTR)TRUE,
 673                         MUIA_FixHeightTxt, (IPTR)"|",
 674                     End),
 675                     Child, (IPTR)(HGroup,
 676                         Child, RectangleObject, End,
 677                         Child, (IPTR)(btn_stop = SimpleButton( _(MSG_BTN_STOP) )),
 678                         Child, RectangleObject, End,
 679                     End),
 680                 End), /* VGroup */
 681             End), /* Window */
 682         End; /* Application */
 683
 684         if ( ! app)
 685         {
 686             message( _(MSG_ERROR_NO_APPLICATION) );
 687             goto cleanup;
 688         }
 689
 690         DoMethod(mainwin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 691             app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 692         DoMethod(btn_cancel, MUIM_Notify, MUIA_Pressed, FALSE,
 693             app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 694         DoMethod(btn_format, MUIM_Notify, MUIA_Pressed, FALSE,
 695             app, 3, MUIM_CallHook, (IPTR)&btn_format_hook, TRUE);
 696         DoMethod(btn_qformat, MUIM_Notify, MUIA_Pressed, FALSE,
 697             app, 3, MUIM_CallHook, (IPTR)&btn_format_hook, FALSE);
 698         DoMethod(btn_stop, MUIM_Notify, MUIA_Pressed, FALSE,
 699             formatwin, 3, MUIM_Set, MUIA_UserData, 1);
 700
 701         set(chk_trash, MUIA_Selected, TRUE);
 702         if( DosType >= 0x444F5300 && DosType <= 0x444F5305 )
 703         {
 704             set(chk_ffs, MUIA_Selected, DosType & 1UL);
 705             set(chk_intl, MUIA_Selected, DosType & 6UL);
 706             set(chk_cache, MUIA_Selected, DosType & 4UL);
 707         }
 708         else
 709         {
 710             set(chk_ffs, MUIA_Disabled, TRUE);
 711             set(chk_intl, MUIA_Disabled, TRUE);
 712             set(chk_cache, MUIA_Disabled, TRUE);
 713         }
 714 #ifdef __AROS__
 715         set(chk_cache, MUIA_Disabled, TRUE);
 716 #endif
 717         set(mainwin, MUIA_Window_Open, TRUE);
 718
 719         if (! XGET(mainwin, MUIA_Window_Open))
 720         {
 721             message( _(MSG_ERROR_NO_WINDOW) );
 722             goto cleanup;
 723         }
 724         DoMethod(app, MUIM_Application_Execute);
 725         rc = RETURN_OK;
 726     }
 727
 728 cleanup:
 729     MUI_DisposeObject(app);
 730
 731 #if DEBUG
 732     SelectInput(OldInput);
 733     SelectOutput(OldOutput);
 734     Close(bpfhStdErr);
 735 #endif
 736
 737     return rc;
 738 }
 739
 740 static void message(CONST_STRPTR s)
 741 {
 742     if (s)
 743     {
 744         D(Printf(s));
 745         MUI_Request(app, NULL, 0, _(MSG_REQ_ERROR_TITLE), _(MSG_OK), s);
 746     }
 747 }