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)_(MSG_SELECTDEVICE),
 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 NULL;
 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         D(Printf("Object name selected via SelectDevice: %s\n", szDosDevice));
 588         /* it's a device */
 589         if( !bSetSzDosDeviceFromSz(szDosDevice) ) {
 590             D(Printf("Bad device name from SelectDevice: %s\n", szDosDevice));
 591             goto cleanup;
 592         }
 593     }
 594
 595 #ifdef AROS_FAKE_LOCK
 596     if (!bGetDosDevice(pdlDevice, LDF_DEVICES|LDF_VOLUMES|LDF_READ))
 597 #else
 598     if (!bGetDosDevice(pdlDevice, LDF_DEVICES|LDF_READ))
 599 #endif
 600         goto cleanup;
 601
 602     RawDoFmtSz( szTitle, _(MSG_WINDOW_TITLE), szDosDevice );
 603     D(Printf("Setting window title to '%s'\n", szTitle));
 604
 605     {
 606         Object *btn_format, *btn_qformat, *btn_cancel, *btn_stop;
 607
 608         btn_format_hook.h_Entry = (HOOKFUNC)btn_format_function;
 609
 610         RawDoFmtSz( szDeviceInfo, _(MSG_DEVICE), szDosDevice );
 611         RawDoFmtSz( szVolumeInfo, _(MSG_VOLUME), szVolumeName );
 612
 613         D(Printf("Creating GUI...\n"));
 614
 615         app = (Object *)ApplicationObject,
 616             MUIA_Application_Title, __(MSG_APPLICATION_TITLE),
 617             MUIA_Application_Version, (IPTR)szVersion,
 618             MUIA_Application_Description, __(MSG_DESCRIPTION),
 619             MUIA_Application_Copyright, __(MSG_COPYRIGHT),
 620             MUIA_Application_Author, __(MSG_AUTHOR),
 621             MUIA_Application_Base, (IPTR)"FORMAT",
 622             MUIA_Application_SingleTask, FALSE,
 623             SubWindow, (IPTR)(mainwin = (Object *)WindowObject,
 624                 MUIA_Window_ID, MAKE_ID('F','R','M','1'),
 625                 MUIA_Window_Title, (IPTR)szTitle,
 626                 WindowContents, (IPTR)(VGroup,
 627                     Child, (IPTR)(ColGroup(2),
 628                         Child, (IPTR)Label2( _(MSG_LABEL_CURRENT_INFORMATION) ),
 629                         Child, (IPTR)(TextObject,
 630                             (IPTR)TextFrame,
 631                             MUIA_Text_Contents, (IPTR)szDeviceInfo,
 632                         End),
 633                         Child, (IPTR)Label2(""),
 634                         Child, (IPTR)(TextObject,
 635                             TextFrame,
 636                             MUIA_Text_Contents, (IPTR)szVolumeInfo,
 637                         End),
 638                         Child, (IPTR)Label2(""),
 639                         Child, (IPTR)(TextObject,
 640                             TextFrame,
 641                             MUIA_Text_Contents, (IPTR)szCapacityInfo,
 642                         End),
 643                         Child, (IPTR)Label2( _(MSG_LABEL_NEW_VOLUME_NAME) ),
 644                         Child, (IPTR)(str_volume = (Object *)StringObject,
 645                             StringFrame,
 646                             MUIA_String_Contents, __(MSG_DEFAULT_VOLUME_NAME),
 647                             MUIA_String_MaxLen, MAX_FS_NAME_LEN,
 648                         End),
 649                         Child, (IPTR)Label2( _(MSG_LABEL_PUT_TRASHCAN) ),
 650                         Child, (IPTR)(chk_trash = MUI_MakeObject(MUIO_Checkmark, NULL)),
 651                         Child, (IPTR)Label2( _(MSG_LABEL_FFS) ),
 652                         Child, (IPTR)(chk_ffs = MUI_MakeObject(MUIO_Checkmark, NULL)),
 653                         Child, (IPTR)Label2( _(MSG_LABEL_INTL)),
 654                         Child, (IPTR)(chk_intl = MUI_MakeObject(MUIO_Checkmark, NULL)),
 655                         Child, (IPTR)Label2( _(MSG_LABEL_CACHE) ),
 656                         Child, (IPTR)(chk_cache = MUI_MakeObject(MUIO_Checkmark, NULL)),
 657                     End), /* ColGroup */
 658                     Child, (IPTR) (RectangleObject,
 659                         MUIA_Rectangle_HBar, TRUE,
 660                         MUIA_FixHeight,      2,
 661                     End),
 662                     Child, (IPTR)(HGroup,
 663                         Child, (IPTR)(btn_format  = ImageButton( _(MSG_BTN_FORMAT) , "THEME:Images/Gadgets/Prefs/Save")),
 664                         Child, (IPTR)(btn_qformat = ImageButton( _(MSG_BTN_QFORMAT), "THEME:Images/Gadgets/Prefs/Save")),
 665                         Child, (IPTR)(btn_cancel  = ImageButton( _(MSG_BTN_CANCEL) , "THEME:Images/Gadgets/Prefs/Cancel")),
 666                     End), /* HGroup */
 667                 End), /* VGroup */
 668             End), /* Window */
 669             SubWindow, (IPTR)(formatwin = (Object *)WindowObject,
 670                 MUIA_Window_ID, MAKE_ID('F','R','M','2'),
 671                 MUIA_Window_Title, (IPTR)szTitle,
 672                 MUIA_Window_CloseGadget, (IPTR)FALSE,
 673                 WindowContents, (IPTR)(VGroup,
 674                     Child, (IPTR)(txt_action = (Object *)TextObject,
 675                         TextFrame,
 676                     End),
 677                     Child, (IPTR)(gauge = (Object *)GaugeObject,
 678                         GaugeFrame,
 679                         MUIA_Gauge_Horiz, (IPTR)TRUE,
 680                         MUIA_FixHeightTxt, (IPTR)"|",
 681                     End),
 682                     Child, (IPTR)(HGroup,
 683                         Child, RectangleObject, End,
 684                         Child, (IPTR)(btn_stop = SimpleButton( _(MSG_BTN_STOP) )),
 685                         Child, RectangleObject, End,
 686                     End),
 687                 End), /* VGroup */
 688             End), /* Window */
 689         End; /* Application */
 690
 691         if ( ! app)
 692         {
 693             message( _(MSG_ERROR_NO_APPLICATION) );
 694             goto cleanup;
 695         }
 696
 697         DoMethod(mainwin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 698             app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 699         DoMethod(btn_cancel, MUIM_Notify, MUIA_Pressed, FALSE,
 700             app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 701         DoMethod(btn_format, MUIM_Notify, MUIA_Pressed, FALSE,
 702             app, 3, MUIM_CallHook, (IPTR)&btn_format_hook, TRUE);
 703         DoMethod(btn_qformat, MUIM_Notify, MUIA_Pressed, FALSE,
 704             app, 3, MUIM_CallHook, (IPTR)&btn_format_hook, FALSE);
 705         DoMethod(btn_stop, MUIM_Notify, MUIA_Pressed, FALSE,
 706             formatwin, 3, MUIM_Set, MUIA_UserData, 1);
 707
 708         set(chk_trash, MUIA_Selected, TRUE);
 709         if( DosType >= 0x444F5300 && DosType <= 0x444F5305 )
 710         {
 711             set(chk_ffs, MUIA_Selected, DosType & 1UL);
 712             set(chk_intl, MUIA_Selected, DosType & 6UL);
 713             set(chk_cache, MUIA_Selected, DosType & 4UL);
 714         }
 715         else
 716         {
 717             set(chk_ffs, MUIA_Disabled, TRUE);
 718             set(chk_intl, MUIA_Disabled, TRUE);
 719             set(chk_cache, MUIA_Disabled, TRUE);
 720         }
 721 #ifdef __AROS__
 722         set(chk_cache, MUIA_Disabled, TRUE);
 723 #endif
 724         set(mainwin, MUIA_Window_Open, TRUE);
 725
 726         if (! XGET(mainwin, MUIA_Window_Open))
 727         {
 728             message( _(MSG_ERROR_NO_WINDOW) );
 729             goto cleanup;
 730         }
 731         DoMethod(app, MUIM_Application_Execute);
 732         rc = RETURN_OK;
 733     }
 734
 735 cleanup:
 736     MUI_DisposeObject(app);
 737
 738 #if DEBUG
 739     SelectInput(OldInput);
 740     SelectOutput(OldOutput);
 741     Close(bpfhStdErr);
 742 #endif
 743
 744     return rc;
 745 }
 746
 747 static void message(CONST_STRPTR s)
 748 {
 749     if (s)
 750     {
 751         D(Printf(s));
 752         MUI_Request(app, NULL, 0, _(MSG_REQ_ERROR_TITLE), _(MSG_OK), s);
 753     }
 754 }