dopus/DOpus_Disk/format.c

   1 /*
   2
   3 Directory Opus 4
   4 Original GPL release version 4.12
   5 Copyright 1993-2000 Jonathan Potter
   6
   7 This program is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU General Public License
   9 as published by the Free Software Foundation; either version 2
  10 of the License, or (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 All users of Directory Opus 4 (including versions distributed
  22 under the GPL) are entitled to upgrade to the latest version of
  23 Directory Opus version 5 at a reduced price. Please see
  24 http://www.gpsoft.com.au for more information.
  25
  26 The release of Directory Opus 4 under the GPL in NO WAY affects
  27 the existing commercial status of Directory Opus 5.
  28
  29 */
  30
  31 #include "diskop.h"
  32
  33 #define FORMATFLAG_FFS             1
  34 #define FORMATFLAG_INTERNATIONAL   2
  35 #define FORMATFLAG_CACHING         4
  36 #define FORMATFLAG_TRASHCAN        8
  37 #define FORMATFLAG_VERIFY         16
  38
  39 enum {
  40         FORMAT_NAME,
  41         FORMAT_FFS,
  42         FORMAT_INTERNATIONAL,
  43         FORMAT_CACHING,
  44         FORMAT_TRASHCAN,
  45         FORMAT_VERIFY,
  46         FORMAT_FORMAT,
  47         FORMAT_QUICKFORMAT,
  48         FORMAT_CANCEL};
  49
  50 struct TagItem
  51         format_name_gadget[]={
  52                 {RO_Type,OBJECT_GADGET},
  53                 {RO_GadgetType,GADGET_STRING},
  54                 {RO_GadgetID,FORMAT_NAME},
  55                 {RO_Left,19},
  56                 {RO_Width,21},
  57                 {RO_Height,1},
  58                 {RO_TextNum,STR_FORMAT_NAME},
  59                 {RO_TextPos,TEXTPOS_LEFT},
  60                 {RO_StringLen,31},
  61                 {TAG_END,0}},
  62         format_ffs_gadget[]={
  63                 {RO_Type,OBJECT_GADGET},
  64                 {RO_GadgetType,GADGET_CHECK},
  65                 {RO_GadgetID,FORMAT_FFS},
  66                 {RO_Left,14},
  67                 {RO_Top,2},
  68                 {RO_TextNum,STR_FORMAT_FFS},
  69                 {RO_TextPos,TEXTPOS_RIGHT},
  70                 {TAG_END,0}},
  71         format_international_gadget[]={
  72                 {RO_Type,OBJECT_GADGET},
  73                 {RO_GadgetType,GADGET_CHECK},
  74                 {RO_GadgetID,FORMAT_INTERNATIONAL},
  75                 {RO_Left,14},
  76                 {RO_Top,3},
  77                 {RO_TopFine,5},
  78                 {RO_TextNum,STR_FORMAT_INTERNATIONAL},
  79                 {RO_TextPos,TEXTPOS_RIGHT},
  80                 {TAG_END,0}},
  81         format_caching_gadget[]={
  82                 {RO_Type,OBJECT_GADGET},
  83                 {RO_GadgetType,GADGET_CHECK},
  84                 {RO_GadgetID,FORMAT_CACHING},
  85                 {RO_Left,14},
  86                 {RO_Top,4},
  87                 {RO_TopFine,10},
  88                 {RO_TextNum,STR_FORMAT_CACHING},
  89                 {RO_TextPos,TEXTPOS_RIGHT},
  90                 {TAG_END,0}},
  91         format_trashcan_gadget[]={
  92                 {RO_Type,OBJECT_GADGET},
  93                 {RO_GadgetType,GADGET_CHECK},
  94                 {RO_GadgetID,FORMAT_TRASHCAN},
  95                 {RO_Left,14},
  96                 {RO_Top,5},
  97                 {RO_TopFine,15},
  98                 {RO_TextNum,STR_FORMAT_TRASHCAN},
  99                 {RO_TextPos,TEXTPOS_RIGHT},
 100                 {TAG_END,0}},
 101         format_verify_gadget[]={
 102                 {RO_Type,OBJECT_GADGET},
 103                 {RO_GadgetType,GADGET_CHECK},
 104                 {RO_GadgetID,FORMAT_VERIFY},
 105                 {RO_Left,14},
 106                 {RO_Top,6},
 107                 {RO_TopFine,20},
 108                 {RO_TextNum,STR_FORMAT_VERIFY},
 109                 {RO_TextPos,TEXTPOS_RIGHT},
 110                 {RO_BoolOn,TRUE},
 111                 {TAG_END,0}},
 112         format_format_gadget[]={
 113                 {RO_Type,OBJECT_GADGET},
 114                 {RO_GadgetType,GADGET_BOOLEAN},
 115                 {RO_GadgetID,FORMAT_FORMAT},
 116                 {RO_Top,8},
 117                 {RO_TopFine,37},
 118                 {RO_Width,13},
 119                 {RO_Height,1},
 120                 {RO_HeightFine,4},
 121                 {RO_TextNum,STR_FORMAT_FORMAT},
 122                 {RO_TextPos,TEXTPOS_CENTER},
 123                 {RO_HighRecess,TRUE},
 124                 {TAG_END,0}},
 125         format_quickformat_gadget[]={
 126                 {RO_Type,OBJECT_GADGET},
 127                 {RO_GadgetType,GADGET_BOOLEAN},
 128                 {RO_GadgetID,FORMAT_QUICKFORMAT},
 129                 {RO_Left,14},
 130                 {RO_Top,8},
 131                 {RO_TopFine,37},
 132                 {RO_Width,13},
 133                 {RO_Height,1},
 134                 {RO_HeightFine,4},
 135                 {RO_TextNum,STR_FORMAT_QUICKFORMAT},
 136                 {RO_TextPos,TEXTPOS_CENTER},
 137                 {RO_HighRecess,TRUE},
 138                 {TAG_END,0}},
 139         format_cancel_gadget[]={
 140                 {RO_Type,OBJECT_GADGET},
 141                 {RO_GadgetType,GADGET_BOOLEAN},
 142                 {RO_GadgetID,FORMAT_CANCEL},
 143                 {RO_Left,28},
 144                 {RO_Top,8},
 145                 {RO_TopFine,37},
 146                 {RO_Width,13},
 147                 {RO_Height,1},
 148                 {RO_HeightFine,4},
 149                 {RO_TextNum,STR_FORMAT_EXIT},
 150                 {RO_TextPos,TEXTPOS_CENTER},
 151                 {RO_HighRecess,TRUE},
 152                 {TAG_END,0}},
 153
 154         format_device_list[]={
 155                 {RO_Type,OBJECT_LISTVIEW},
 156                 {RO_ListViewID,0},
 157                 {RO_LeftFine,2},
 158                 {RO_Width,10},
 159                 {RO_Height,6},
 160                 {RO_HeightFine,30},
 161                 {RO_HighRecess,TRUE},
 162                 {TAG_END,0}},
 163
 164         format_info_box[]={
 165                 {RO_Type,OBJECT_BORDER},
 166                 {RO_BorderType,BORDER_RECESSED},
 167                 {RO_LeftFine,2},
 168                 {RO_Top,7},
 169                 {RO_TopFine,28},
 170                 {RO_Width,41},
 171                 {RO_WidthFine,-4},
 172                 {RO_Height,1},
 173                 {RO_HeightFine,4},
 174                 {TAG_END,0}},
 175
 176         *format_gadgets[]={
 177                 format_name_gadget,
 178                 format_ffs_gadget,
 179                 format_international_gadget,
 180                 format_caching_gadget,
 181                 format_trashcan_gadget,
 182                 format_verify_gadget,
 183                 format_format_gadget,
 184                 format_quickformat_gadget,
 185                 format_cancel_gadget,
 186                 NULL};
 187
 188 void diskop_format(vis,portname,argc,argv)
 189 struct VisInfo *vis;
 190 char *portname;
 191 int argc;
 192 char *argv[];
 193 {
 194         struct RequesterBase formatreq;
 195         struct Window *window;
 196         struct IntuiMessage *msg;
 197         Object_Border *infobox;
 198         struct DOpusListView *devicelist,*view;
 199         struct Gadget *gadlist,*gad,*gad_international=NULL,*gad_caching=NULL;
 200         ULONG class,mask,flags;
 201         UWORD code,gadgetid;
 202         APTR iaddress;
 203         struct StringExtend stringex;
 204         char *diskname;
 205         int a,b,gadcount=0,ignorechange=0;
 206         int start=-1,quick=0,startflags=FORMATFLAG_TRASHCAN;
 207
 208         formatreq.rb_width=41;
 209         formatreq.rb_height=9;
 210         formatreq.rb_widthfine=16;
 211         formatreq.rb_heightfine=54;
 212         formatreq.rb_leftoffset=8;
 213         formatreq.rb_topoffset=8;
 214         formatreq.rb_flags=0;
 215
 216         fill_out_req(&formatreq,vis);
 217
 218         formatreq.rb_privateflags=0;
 219         formatreq.rb_screenname=NULL;
 220
 221         if (formatreq.rb_screen && !(vis->vi_flags&VISF_BORDERS)) {
 222                 formatreq.rb_flags|=RBF_STRINGS;
 223                 formatreq.rb_title=NULL;
 224         }
 225         else {
 226                 formatreq.rb_flags|=RBF_BORDERS|RBF_CLOSEGAD|RBF_STRINGS;
 227                 formatreq.rb_title=string_table[STR_FORMAT_FORMAT];
 228         }
 229
 230         formatreq.rb_extend=&stringex;
 231         formatreq.rb_idcmpflags=0;
 232         formatreq.rb_string_table=string_table;
 233
 234         for (a=0;a<2;a++) {
 235                 stringex.Pens[a]=vis->vi_stringcol[a];
 236                 stringex.ActivePens[a]=vis->vi_activestringcol[a];
 237         }
 238         stringex.InitialModes=0;
 239         stringex.EditHook=NULL;
 240         stringex.WorkBuffer=NULL;
 241         for (a=0;a<4;a++) stringex.Reserved[a]=0;
 242
 243         if (SysBase->LibNode.lib_Version<39) mask=12;
 244         else mask=0;
 245
 246         if (!(window=OpenRequester(&formatreq)) ||
 247                 !(gadlist=addreqgadgets(&formatreq,format_gadgets,mask,&gadcount)) ||
 248                 !(infobox=(Object_Border *)
 249                         AddRequesterObject(&formatreq,format_info_box)) ||
 250                 !(devicelist=(struct DOpusListView *)
 251                         AddRequesterObject(&formatreq,format_device_list)) ||
 252                 !(devicelist->items=get_device_list(&formatreq.rb_memory,NULL))) {
 253                 CloseRequester(&formatreq);
 254                 return;
 255         }
 256
 257         fix_listview(&formatreq,devicelist);
 258         select_device(devicelist,NULL);
 259
 260         diskname=((struct StringInfo *)gadlist->SpecialInfo)->Buffer;
 261         strcpy(diskname,string_table[STR_FORMAT_EMPTY]);
 262
 263         get_env("format",gadlist,gadcount,devicelist);
 264
 265         flags=0;
 266         gad=gadlist;
 267         for (a=0;a<gadcount;a++) {
 268                 if (gad->Activation&GACT_TOGGLESELECT)
 269                         if (gad->Flags&GFLG_SELECTED) flags|=1<<(gad->GadgetID-1);
 270                 gad->Flags&=~GFLG_DISABLED;
 271                 gad=gad->NextGadget;
 272         }
 273
 274         if (SysBase->LibNode.lib_Version>38) {
 275                 gad_international=gadlist->NextGadget->NextGadget;
 276                 gad_caching=gad_international->NextGadget;
 277         }
 278
 279         for (a=0;a<argc;a++) {
 280                 if (LStrCmpI(argv[a],"quick")==0) quick=1;
 281                 else if (LStrCmpI(argv[a],"ffs")==0) startflags|=FORMATFLAG_FFS;
 282                 else if (LStrCmpI(argv[a],"cache")==0) startflags|=FORMATFLAG_CACHING;
 283                 else if (LStrnCmpI(argv[a],"inter",5)==0) startflags|=FORMATFLAG_INTERNATIONAL;
 284                 else if (LStrCmpI(argv[a],"noicons")==0) startflags&=~FORMATFLAG_TRASHCAN;
 285                 else if (LStrCmpI(argv[a],"verify")==0) startflags|=FORMATFLAG_VERIFY;
 286                 else {
 287                         if (start==-1) {
 288                                 for (b=0;devicelist->items[b];b++) {
 289                                         if (LStrCmpI(argv[a],devicelist->items[b])==0) {
 290                                                 start=b;
 291                                                 devicelist->itemselected=b;
 292                                                 break;
 293                                         }
 294                                 }
 295                         }
 296                         else LStrnCpy(diskname,argv[a],30);
 297                 }
 298         }
 299
 300         if (start>-1) {
 301                 gad=gadlist;
 302                 for (a=0;a<gadcount;a++) {
 303                         if (startflags&(1<<(gad->GadgetID-1))) gad->Flags|=GFLG_SELECTED;
 304                         else gad->Flags&=~GFLG_SELECTED;
 305                         gad=gad->NextGadget;
 306                 }
 307         }
 308
 309         RefreshRequesterObject(&formatreq,NULL);
 310         RefreshGList(gadlist,window,NULL,gadcount);
 311
 312         if (flags&FORMATFLAG_CACHING && gad_international) {
 313                 flags|=FORMATFLAG_INTERNATIONAL;
 314                 gad_international->Flags|=GFLG_SELECTED;
 315                 RefreshGList(gad_international,window,NULL,1);
 316                 DisableGadget(gad_international,window->RPort,0,0);
 317         }
 318
 319         if (!(AddListView(devicelist,1))) {
 320                 CloseRequester(&formatreq);
 321                 return;
 322         }
 323         show_sel_item(devicelist);
 324         show_device_info(&formatreq,infobox,devicelist->items[devicelist->itemselected]);
 325
 326         if (start>-1) {
 327                 if (do_format(&formatreq,
 328                         infobox,
 329                         devicelist->items[start],
 330                         diskname,
 331                         startflags,
 332                         quick))
 333                         dopus_message(DOPUSMSG_UPDATEDRIVE,(APTR)devicelist->items[start],portname);
 334                 RemoveListView(devicelist,1);
 335                 CloseRequester(&formatreq);
 336                 return;
 337         }
 338
 339         FOREVER {
 340                 while (msg=(struct IntuiMessage *)GetMsg(window->UserPort)) {
 341                         if ((view=(struct DOpusListView *)ListViewIDCMP(devicelist,msg))==
 342                                 (struct DOpusListView *)-1) {
 343                                 class=msg->Class; code=msg->Code;
 344                                 iaddress=msg->IAddress;
 345                                 ReplyMsg((struct Message *)msg);
 346
 347                                 switch (class) {
 348                                         case IDCMP_DISKINSERTED:
 349                                         case IDCMP_DISKREMOVED:
 350                                                 if (ignorechange) ignorechange=0;
 351                                                 else {
 352                                                         show_device_info(&formatreq,
 353                                                                 infobox,
 354                                                                 devicelist->items[devicelist->itemselected]);
 355                                                 }
 356                                                 break;
 357
 358                                         case IDCMP_VANILLAKEY:
 359                                                 a=0;
 360                                                 code=ToUpper(code);
 361                                                 switch (code) {
 362                                                         case 'N':
 363                                                                 ActivateStrGad(gadlist,window);
 364                                                                 break;
 365                                                         case 'F':
 366                                                                 a=1;
 367                                                                 flags^=FORMATFLAG_FFS;
 368                                                                 break;
 369                                                         case 'I':
 370                                                                 if (SysBase->LibNode.lib_Version>38) {
 371                                                                         a=2;
 372                                                                         flags^=FORMATFLAG_INTERNATIONAL;
 373                                                                 }
 374                                                                 break;
 375                                                         case 'D':
 376                                                                 if (SysBase->LibNode.lib_Version>38) {
 377                                                                         a=3;
 378                                                                         flags^=FORMATFLAG_CACHING;
 379                                                                 }
 380                                                                 break;
 381                                                         case 'P':
 382                                                                 if (SysBase->LibNode.lib_Version>38) a=4;
 383                                                                 else a=2;
 384                                                                 flags^=FORMATFLAG_TRASHCAN;
 385                                                                 break;
 386                                                         case 'V':
 387                                                                 if (SysBase->LibNode.lib_Version>38) a=5;
 388                                                                 else a=3;
 389                                                                 flags^=FORMATFLAG_VERIFY;
 390                                                                 break;
 391
 392                                                         case 0x1b:
 393                                                                 set_env("format",gadlist,gadcount,devicelist);
 394                                                                 RemoveListView(devicelist,1);
 395                                                                 CloseRequester(&formatreq);
 396                                                                 return;
 397                                                 }
 398                                                 if (a) {
 399                                                         gad=gadlist;
 400                                                         while (a-- && gad->NextGadget) gad=gad->NextGadget;
 401                                                         gad->Flags^=GFLG_SELECTED;
 402                                                         RefreshGList(gad,window,NULL,1);
 403                                                         if (gad==gad_international) {
 404                                                                 gad_caching->Flags&=~GFLG_SELECTED;
 405                                                                 RefreshGList(gad_caching,window,NULL,1);
 406                                                                 flags&=~FORMATFLAG_CACHING;
 407                                                         }
 408                                                         else if (gad==gad_caching) {
 409                                                                 gad_international->Flags&=~GFLG_SELECTED;
 410                                                                 RefreshGList(gad_international,window,NULL,1);
 411                                                                 flags&=~FORMATFLAG_INTERNATIONAL;
 412                                                         }
 413                                                 }
 414                                                 break;
 415
 416                                         case IDCMP_GADGETDOWN:
 417                                         case IDCMP_GADGETUP:
 418                                                 gadgetid=((struct Gadget *)iaddress)->GadgetID;
 419                                         case IDCMP_CLOSEWINDOW:
 420                                                 if (class==IDCMP_CLOSEWINDOW) gadgetid=FORMAT_CANCEL;
 421
 422                                                 switch (gadgetid) {
 423                                                         case FORMAT_FFS:
 424                                                                 flags^=FORMATFLAG_FFS;
 425                                                                 break;
 426
 427                                                         case FORMAT_INTERNATIONAL:
 428                                                                 flags^=FORMATFLAG_INTERNATIONAL;
 429                                                                 flags&=~FORMATFLAG_CACHING;
 430                                                                 gad_caching->Flags&=~GFLG_SELECTED;
 431                                                                 RefreshGList(gad_caching,window,NULL,1);
 432                                                                 break;
 433
 434                                                         case FORMAT_CACHING:
 435                                                                 flags^=FORMATFLAG_CACHING;
 436                                                                 if (flags&FORMATFLAG_CACHING) {
 437                                                                         flags|=FORMATFLAG_INTERNATIONAL;
 438                                                                         gad_international->Flags|=GFLG_SELECTED;
 439                                                                         RefreshGList(gad_international,window,NULL,1);
 440                                                                         DisableGadget(gad_international,window->RPort,0,0);
 441                                                                 }
 442                                                                 else EnableGadget(gad_international,window->RPort,0,0);
 443                                                                 break;
 444
 445                                                         case FORMAT_TRASHCAN:
 446                                                                 flags^=FORMATFLAG_TRASHCAN;
 447                                                                 break;
 448
 449                                                         case FORMAT_VERIFY:
 450                                                                 flags^=FORMATFLAG_VERIFY;
 451                                                                 break;
 452
 453                                                         case FORMAT_CANCEL:
 454                                                                 set_env("format",gadlist,gadcount,devicelist);
 455                                                                 RemoveListView(devicelist,1);
 456                                                                 CloseRequester(&formatreq);
 457                                                                 return;
 458
 459                                                         case FORMAT_FORMAT:
 460                                                         case FORMAT_QUICKFORMAT:
 461                                                                 if (do_format(&formatreq,
 462                                                                         infobox,
 463                                                                         devicelist->items[devicelist->itemselected],
 464                                                                         diskname,
 465                                                                         flags,
 466                                                                         (gadgetid==FORMAT_QUICKFORMAT))) {
 467                                                                         ignorechange=1;
 468                                                                         dopus_message(DOPUSMSG_UPDATEDRIVE,
 469                                                                                 (APTR)devicelist->items[devicelist->itemselected],
 470                                                                                 portname);
 471                                                                 }
 472                                                                 break;
 473                                                 }
 474                                                 break;
 475                                 }
 476                         }
 477                         else if (view) show_device_info(&formatreq,infobox,view->items[view->itemselected]);
 478                 }
 479                 Wait(1<<window->UserPort->mp_SigBit);
 480         }
 481 }
 482
 483 void show_device_info(reqbase,border,name)
 484 struct RequesterBase *reqbase;
 485 Object_Border *border;
 486 char *name;
 487 {
 488         struct DeviceNode *devnode;
 489         struct DosEnvec *dosenvec;
 490         int tracks,tracksize,size;
 491         char infobuf[60],sizebuf[20];
 492
 493         border_text(reqbase,border,NULL);
 494
 495         if (!name || !(devnode=find_device(name))) return;
 496
 497         dosenvec=(struct DosEnvec *)
 498                 BADDR(((struct FileSysStartupMsg *)BADDR(devnode->dn_Startup))->fssm_Environ);
 499
 500         tracks=dosenvec->de_HighCyl-dosenvec->de_LowCyl+1;
 501         tracksize=(dosenvec->de_BlocksPerTrack*dosenvec->de_Surfaces)*(dosenvec->de_SizeBlock*4);
 502         size=tracks*tracksize;
 503
 504         getsizestring(sizebuf,size);
 505         lsprintf(infobuf,string_table[STR_FORMAT_INFODISPLAY],tracks,tracksize,sizebuf);
 506
 507         border_text(reqbase,border,infobuf);
 508 }
 509
 510 void getsizestring(buf,a)
 511 char *buf;
 512 ULONG a;
 513 {
 514         a/=1024;
 515         if (a>1073741824) lsprintf(buf,"HUGE");
 516         else if (a>1048576) {
 517                 getfloatstr((double)((double)a/1048576),buf);
 518                 LStrCat(buf,"G");
 519         }
 520         else if (a>1024) {
 521                 getfloatstr((double)((double)a/1024),buf);
 522                 LStrCat(buf,"M");
 523         }
 524         else lsprintf(buf,"%ldK",a);
 525 }
 526
 527 void getfloatstr(f,buf)
 528 double f;
 529 char *buf;
 530 {
 531         int a,b,c,d;
 532         char buf1[20];
 533
 534         a=(int)f; f-=a;
 535         b=(int)(f*100);
 536         c=(b/10)*10; d=b-c;
 537         if (d>4) c+=10;
 538         if (c==100) {
 539                 c=0; ++a;
 540         }
 541         lsprintf(buf1,"%ld",c); buf1[1]=0;
 542         lsprintf(buf,"%ld.%s",a,buf1);
 543 }
 544
 545 do_format(reqbase,border,device,name,flags,quick)
 546 struct RequesterBase *reqbase;
 547 Object_Border *border;
 548 char *device,*name;
 549 ULONG flags;
 550 char quick;
 551 {
 552         ULONG dostype;
 553         struct DeviceHandle handle;
 554         int suc=1,txt=STR_FAILED_ERROR;
 555         struct Requester busyreq;
 556
 557         if (flags&FORMATFLAG_INTERNATIONAL) {
 558                 if (flags&FORMATFLAG_FFS) dostype=ID_INTER_FFS_DISK;
 559                 else dostype=ID_INTER_DOS_DISK;
 560         }
 561         else if (flags&FORMATFLAG_CACHING) {
 562                 if (flags&FORMATFLAG_FFS) dostype=ID_FASTDIR_FFS_DISK;
 563                 else dostype=ID_FASTDIR_DOS_DISK;
 564         }
 565         else if (flags&FORMATFLAG_FFS) dostype=ID_FFS_DISK;
 566         else dostype=ID_DOS_DISK;
 567
 568         if (!(open_device(device,&handle))) txt=STR_NODEVICE_ERROR;
 569         else {
 570                 InitRequester(&busyreq);
 571                 busyreq.Flags=NOISYREQ;
 572                 Request(&busyreq,reqbase->rb_window);
 573                 SetBusyPointer(reqbase->rb_window);
 574
 575                 border_text(reqbase,border,string_table[STR_CHECKING_DESTINATION]);
 576
 577                 if (check_disk(reqbase,handle.device_req,device,1)) {
 578                         if (check_blank_disk(reqbase,device,string_table[STR_FORMAT_FORMAT])) {
 579
 580                                 suc=0;
 581
 582                                 inhibit_drive(device,DOSTRUE);
 583                                 drive_motor(handle.device_req,1);
 584
 585                                 if (!quick) {
 586                                         suc=do_raw_format(reqbase,border,
 587                                                 handle.device_req,
 588                                                 (handle.dosenvec->de_SizeBlock<<2)*
 589                                                         handle.dosenvec->de_Surfaces*handle.dosenvec->de_BlocksPerTrack,
 590                                                 handle.dosenvec->de_LowCyl,
 591                                                 handle.dosenvec->de_HighCyl-handle.dosenvec->de_LowCyl+1,
 592                                                 handle.dosenvec->de_BufMemType,
 593                                                 flags);
 594                                 }
 595
 596                                 if (!suc) {
 597                                         border_text(reqbase,border,string_table[STR_FORMAT_INITIALISING]);
 598
 599                                         if (DOSBase->dl_lib.lib_Version>36) {
 600                                                 if (Format(device,name,dostype)) suc=0;
 601                                                 else suc=ERROR_FAILED;
 602                                         }
 603                                         else {
 604                                                 suc=do_initialise(handle.device_req,name,dostype,
 605                                                         handle.dosenvec->de_LowCyl*
 606                                                                 handle.dosenvec->de_BlocksPerTrack*
 607                                                                 handle.dosenvec->de_Surfaces,
 608                                                         (handle.dosenvec->de_HighCyl-handle.dosenvec->de_LowCyl+1)*
 609                                                                 handle.dosenvec->de_BlocksPerTrack*handle.dosenvec->de_Surfaces,
 610                                                         handle.dosenvec->de_Reserved,
 611                                                         handle.dosenvec->de_BufMemType,
 612                                                         flags);
 613                                         }
 614                                 }
 615
 616                                 drive_motor(handle.device_req,0);
 617                                 inhibit_drive(device,FALSE);
 618
 619                                 switch (suc) {
 620                                         case 0:
 621                                                 if (flags&FORMATFLAG_TRASHCAN) {
 622                                                         if (SysBase->LibNode.lib_Version<36) Delay(150);
 623                                                         write_trashcan(reqbase,border,device);
 624                                                 }
 625                                                 txt=STR_SUCCESS;
 626                                                 break;
 627                                         case ERROR_FAILED: txt=STR_FAILED_ERROR; break;
 628                                         case ERROR_MEMORY: txt=STR_MEMORY_ERROR; break;
 629                                         case ERROR_BITMAP: txt=STR_BITMAP_ERROR; break;
 630                                         case ERROR_ABORTED: txt=STR_ABORTED; break;
 631                                         case ERROR_VERIFY: txt=-1; break;
 632                                         default: txt=STR_DEVICE_ERROR; break;
 633                                 }
 634                         }
 635                         else txt=STR_ABORTED;
 636                 }
 637                 else txt=STR_ABORTED;
 638
 639                 EndRequest(&busyreq,reqbase->rb_window);
 640                 ClearPointer(reqbase->rb_window);
 641         }
 642
 643         close_device(&handle);
 644         if (txt>-1) border_text(reqbase,border,string_table[txt]);
 645         return((txt==STR_SUCCESS));
 646 }
 647
 648 do_initialise(device_req,name,dostype,firstblock,numblocks,reserved,memtype,flags)
 649 struct IOExtTD *device_req;
 650 char *name;
 651 ULONG dostype;
 652 ULONG firstblock,numblocks,reserved;
 653 ULONG memtype;
 654 ULONG flags;
 655 {
 656         ULONG *bitmap,bitmapsize;
 657         char *buffer;
 658         struct BitmapBlock *bitmapblock;
 659         struct BitmapExtension *bitmapextension;
 660         struct RootDirectory *rootdirectory;
 661         struct DOpusRemember *key=NULL;
 662         LONG error,a;
 663         LONG bitmapcount,bitmapblocks;
 664         LONG count,root;
 665         LONG extensioncount,extensionblocks=0;
 666
 667         bitmapsize=(numblocks-reserved+31)/32;
 668
 669         if (!(buffer=LAllocRemember(&key,TD_SECTOR,memtype|MEMF_PUBLIC|MEMF_CLEAR)))
 670                 return(ERROR_MEMORY);
 671
 672         *(ULONG *)buffer=dostype;
 673
 674         for (a=0;a<2;a++) {
 675                 if (error=do_writeblock(device_req,buffer,firstblock+a)) {
 676                         LFreeRemember(&key);
 677                         return(error);
 678                 }
 679                 *(ULONG *)buffer=0;
 680         }
 681
 682         if (!(bitmap=(ULONG *)LAllocRemember(&key,sizeof(ULONG)*bitmapsize,MEMF_PUBLIC))) {
 683                 LFreeRemember(&key);
 684                 return(ERROR_MEMORY);
 685         }
 686
 687         for (a=0;a<bitmapsize;a++) bitmap[a]=~0;
 688
 689         count=bitmapblocks=(bitmapsize+126)/127;
 690
 691         if (count>25) {
 692                 if (!(flags&FORMATFLAG_FFS)) {
 693                         LFreeRemember(&key);
 694                         return(ERROR_BITMAP);
 695                 }
 696                 count-=25;
 697
 698                 do {
 699                         ++extensionblocks;
 700
 701                         if (count>127) count-=127;
 702                         else count=0;
 703                 }
 704                 while (count);
 705         }
 706
 707         root=numblocks>>1;
 708         rootdirectory=(struct RootDirectory *)buffer;
 709         for (a=0;a<TD_SECTOR;a++) buffer[a]=0;
 710
 711         rootdirectory->PrimaryType=2;
 712         rootdirectory->HashTableSize=128-56;
 713         rootdirectory->BitmapFlag=DOSTRUE;
 714         DateStamp(&rootdirectory->LastRootChange);
 715
 716         if ((a=strlen(name))>31) a=31;
 717
 718         rootdirectory->DiskName[0]=a;
 719         CopyMem(name,&rootdirectory->DiskName[1],a);
 720
 721         DateStamp(&rootdirectory->LastDiskChange);
 722         DateStamp(&rootdirectory->CreationDate);
 723
 724         rootdirectory->SecondaryType=1;
 725
 726         for (a=0;a<bitmapblocks;a++) {
 727                 if (a==25) break;
 728                 rootdirectory->BitmapPointers[a]=root+firstblock+a+1;
 729         }
 730
 731         if (bitmapblocks>25) rootdirectory->BitmapExtension=root+firstblock+26;
 732         rootdirectory->Checksum=-do_checksum((ULONG *)rootdirectory);
 733
 734         if (error=do_writeblock(device_req,rootdirectory,root+firstblock)) {
 735                 LFreeRemember(&key);
 736                 return(error);
 737         }
 738
 739         for (a=root-reserved;a<root-reserved+bitmapblocks+extensionblocks+1;a++)
 740                 bitmap[a/32]&=BitTable[a%32];
 741
 742         bitmapblock=(struct BitmapBlock *)buffer;
 743
 744         for (a=0;a<bitmapblocks;a++) {
 745                 CopyMem(&bitmap[a*127],&bitmapblock->Bitmap[0],sizeof(ULONG)*127);
 746                 bitmapblock->Checksum=0;
 747                 bitmapblock->Checksum=-do_checksum((ULONG *)bitmapblock);
 748                 if (error=do_writeblock(device_req,bitmapblock,root+firstblock+a+1)) {
 749                         LFreeRemember(&key);
 750                         return(error);
 751                 }
 752         }
 753
 754         if (extensionblocks) {
 755                 bitmapextension=(struct BitmapExtension *)buffer;
 756
 757                 bitmapcount=root+firstblock+1;
 758                 extensioncount=bitmapcount+bitmapblocks;
 759                 bitmapblocks-=25;
 760
 761                 while (bitmapblocks) {
 762                         for (a=0;a<TD_SECTOR;a++) buffer[a]=0;
 763                         for (a=0;a<(bitmapblocks<127?bitmapblocks:127);a++)
 764                                 bitmapextension->BitmapPointers[a]=bitmapcount++;
 765                         if (bitmapblocks>127) bitmapblocks-=127;
 766                         else bitmapblocks=0;
 767
 768                         if (bitmapblocks) bitmapextension->BitmapExtension=extensioncount+1;
 769                         if (error=do_writeblock(device_req,bitmapextension,extensioncount++)) {
 770                                 LFreeRemember(&key);
 771                                 return(error);
 772                         }
 773                 }
 774         }
 775
 776         LFreeRemember(&key);
 777         return(0);
 778 }
 779
 780 do_raw_format(reqbase,border,device_req,tracksize,lowtrack,numtracks,memtype,flags)
 781 struct RequesterBase *reqbase;
 782 Object_Border *border;
 783 struct IOExtTD *device_req;
 784 ULONG tracksize,lowtrack,numtracks;
 785 ULONG memtype;
 786 ULONG flags;
 787 {
 788         ULONG *trackbuffer,*verifybuffer;
 789         struct DOpusRemember *key=NULL;
 790         ULONG offset;
 791         int track,a,cmpsize,ret;
 792         char infobuf[80];
 793
 794         if (!(trackbuffer=(ULONG *)LAllocRemember(&key,tracksize,memtype|MEMF_CLEAR)))
 795                 return(ERROR_MEMORY);
 796         if (flags&FORMATFLAG_VERIFY) {
 797                 verifybuffer=(ULONG *)LAllocRemember(&key,tracksize,memtype);
 798                 cmpsize=tracksize>>2;
 799         }
 800         else verifybuffer=NULL;
 801
 802         offset=lowtrack*tracksize;
 803
 804         for (track=0;track<numtracks;track++) {
 805                 lsprintf(infobuf,string_table[STR_FORMAT_FORMATTING],track,numtracks-track-1);
 806                 border_text(reqbase,border,infobuf);
 807
 808                 FOREVER {
 809                         if (check_abort(reqbase->rb_window)) {
 810                                 LFreeRemember(&key);
 811                                 return(ERROR_ABORTED);
 812                         }
 813
 814                         device_req->iotd_Req.io_Command=TD_FORMAT;
 815                         device_req->iotd_Req.io_Data=(APTR)trackbuffer;
 816                         device_req->iotd_Req.io_Offset=offset;
 817                         device_req->iotd_Req.io_Length=tracksize;
 818
 819                         if (!(DoIO((struct IORequest *)device_req))) {
 820                                 if (!verifybuffer) break;
 821                                 device_req->iotd_Req.io_Command=CMD_UPDATE;
 822                                 if (!(DoIO((struct IORequest *)device_req))) break;
 823                         }
 824
 825                         lsprintf(infobuf,string_table[STR_FORMAT_FORMATERROR],track);
 826                         border_text(reqbase,border,infobuf);
 827                         if (!(check_error(reqbase,infobuf,STR_RETRY))) {
 828                                 LFreeRemember(&key);
 829                                 return(ERROR_FAILED);
 830                         }
 831                 }
 832
 833                 if (verifybuffer) {
 834                         lsprintf(infobuf,string_table[STR_FORMAT_VERIFYING],track,numtracks-track-1);
 835                         border_text(reqbase,border,infobuf);
 836
 837                         FOREVER {
 838                                 if (check_abort(reqbase->rb_window)) {
 839                                         LFreeRemember(&key);
 840                                         return(ERROR_ABORTED);
 841                                 }
 842
 843                                 device_req->iotd_Req.io_Command=CMD_READ;
 844                                 device_req->iotd_Req.io_Data=(APTR)verifybuffer;
 845                                 device_req->iotd_Req.io_Offset=offset;
 846                                 device_req->iotd_Req.io_Length=tracksize;
 847
 848                                 if (!(DoIO((struct IORequest *)device_req))) {
 849                                         for (a=0;a<cmpsize;a++) {
 850                                                 if (verifybuffer[a]!=0) break;
 851                                         }
 852                                         if (a==cmpsize) break;
 853                                         lsprintf(infobuf,string_table[STR_FORMAT_VERIFYERROR],track);
 854                                         ret=ERROR_VERIFY;
 855                                 }
 856                                 else {
 857                                         lsprintf(infobuf,string_table[STR_FORMAT_FORMATERROR],track);
 858                                         ret=ERROR_FAILED;
 859                                 }
 860
 861                                 border_text(reqbase,border,infobuf);
 862                                 if (!(check_error(reqbase,infobuf,STR_RETRY))) {
 863                                         LFreeRemember(&key);
 864                                         return(ret);
 865                                 }
 866                         }
 867                 }
 868
 869                 offset+=tracksize;
 870         }
 871         LFreeRemember(&key);
 872         return(0);
 873 }
 874
 875 void write_trashcan(reqbase,border,device)
 876 struct RequesterBase *reqbase;
 877 Object_Border *border;
 878 char *device;
 879 {
 880         struct DiskObject *trashcan;
 881         BPTR lock;
 882         char name[80];
 883
 884         if (!IconBase) return;
 885
 886         border_text(reqbase,border,string_table[STR_FORMAT_MAKINGTRASHCAN]);
 887
 888         lsprintf(name,"%sTrashcan",device);
 889         if (!(lock=CreateDir(name))) return;
 890         UnLock(lock);
 891
 892         if (IconBase->lib_Version>36 &&
 893                 (trashcan=GetDefDiskObject(WBGARBAGE))) {
 894                 PutDiskObject(name,trashcan);
 895                 FreeDiskObject(trashcan);
 896         }
 897         else PutDiskObject(name,&trashcanicon_icon);
 898 }