workbench/system/Wanderer/Tools/DiskInfo/diskinfo.c

   1 /*
   2     Copyright © 2005-2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #define DEBUG 0
   9 #include <aros/debug.h>
  10
  11 #include <exec/types.h>
  12 #include <utility/tagitem.h>
  13 #include <libraries/mui.h>
  14 #include <libraries/asl.h>
  15 #include <dos/filehandler.h>
  16
  17 #include <proto/exec.h>
  18 #include <proto/dos.h>
  19 #include <proto/intuition.h>
  20 #include <proto/utility.h>
  21 #include <proto/icon.h>
  22 #include <proto/muimaster.h>
  23 #include <proto/workbench.h>
  24
  25 #include <stdio.h>
  26
  27 #include <zune/iconimage.h>
  28 #include "diskinfo.h"
  29 #include "locale.h"
  30 #include "support.h"
  31
  32 #define MINUSER 1
  33 #define NOVICE 0
  34 #define AVERAGE 1
  35 #define ADVANCED 1
  36 #define EXPERT 2
  37
  38 #ifndef ID_FAT12_DISK
  39 #define ID_FAT12_DISK      (0x46415400L)
  40 #define ID_FAT16_DISK      (0x46415401L)
  41 #define ID_FAT32_DISK      (0x46415402L)
  42 #endif
  43 #ifndef ID_CDFS_DISK
  44 #define ID_CDFS_DISK       (0x43444653L)
  45 #endif
  46
  47 static LONG dt[]={ID_NO_DISK_PRESENT, ID_UNREADABLE_DISK,
  48     ID_DOS_DISK, ID_FFS_DISK, ID_INTER_DOS_DISK, ID_INTER_FFS_DISK,
  49     ID_FASTDIR_DOS_DISK, ID_FASTDIR_FFS_DISK, ID_NOT_REALLY_DOS,
  50     ID_KICKSTART_DISK, ID_MSDOS_DISK, ID_SFS_BE_DISK, ID_SFS_LE_DISK,
  51     ID_FAT12_DISK, ID_FAT16_DISK, ID_FAT32_DISK, ID_CDFS_DISK };
  52
  53 /*** Instance data **********************************************************/
  54 struct DiskInfo_DATA
  55 {
  56     Object                      *dki_Window;
  57     Object                      *dki_VolumeIcon;
  58     Object                      *dki_VolumeName;
  59     Object                      *dki_VolumeUseGauge;
  60     Object                      *dki_VolumeUsed;
  61     Object                      *dki_VolumeFree;
  62     char                        *dki_DOSDev;
  63     struct MsgPort              *dki_NotifyPort;
  64     LONG                        dki_DiskType;
  65     LONG                        dki_Aspect;
  66     struct MUI_InputHandlerNode dki_NotifyIHN;
  67     struct NotifyRequest        dki_FSNotifyRequest;
  68 };
  69
  70 /*** Methods ****************************************************************/
  71 Object *DiskInfo__OM_NEW
  72 (
  73     Class *CLASS, Object *self, struct opSet *message
  74 )
  75 {
  76     struct DiskInfo_DATA        *data           = NULL;
  77     const struct TagItem        *tstate         = message->ops_AttrList;
  78     struct TagItem              *tag            = NULL;
  79     BPTR                        initial        = NULL;
  80     Object                      *window,
  81                                 *volnameobj, *voliconobj, *volusegaugeobj, *volusedobj, *volfreeobj,
  82                                 *grp, *grpformat;
  83     ULONG                       percent        = 0;
  84     LONG                        disktype       = ID_NO_DISK_PRESENT;
  85     LONG                        aspect         = 0;
  86     TEXT                        volname[108];
  87     TEXT                        size[64];
  88     TEXT                        used[64];
  89     TEXT                        free[64];
  90     TEXT                        blocksize[16];
  91     STRPTR                      status = NULL;
  92     STRPTR                      dosdevname = NULL;
  93     STRPTR                      filesystem = NULL;
  94     STRPTR                      fstype = NULL;
  95     STRPTR                      fshandler = NULL;
  96     STRPTR                      volicon = NULL;
  97     STRPTR                      handlertype = "";
  98     STRPTR                      deviceinfo = "";
  99
 100     struct DosList              *dl, *dn;
 101     BOOL                        disktypefound = FALSE;
 102
 103     static struct InfoData id;
 104
 105     static STRPTR disktypelist[] =
 106     {
 107         "No Disk",
 108         "Unreadable",
 109         "OFS",
 110         "FFS",
 111         "OFS-Intl",
 112         "FFS-Intl",
 113         "OFS-DC",
 114         "FFS-DC",
 115         "Not DOS",
 116         "KickStart",
 117         "MSDOS",
 118         "SFS0 BE",
 119         "SFS0 LE",
 120         "FAT12",
 121         "FAT16",
 122         "FAT32",
 123         "CD-ROM"
 124     };
 125
 126     /* Parse initial taglist -----------------------------------------------*/
 127     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 128
 129     while ((tag = NextTagItem(&tstate)) != NULL)
 130     {
 131         switch (tag->ti_Tag)
 132         {
 133             case MUIA_DiskInfo_Initial:
 134                 initial = (BPTR) tag->ti_Data;
 135                 D(bug("[DiskInfo] %s: initial lock @ 0x%p\n", __PRETTY_FUNCTION__, initial));
 136                 break;
 137 #warning "TODO: Remove MUIA_DiskInfo_Aspect"
 138             case MUIA_DiskInfo_Aspect:
 139                 aspect = tag->ti_Data;
 140                 D(bug("[DiskInfo] %s: aspect: %d\n", __PRETTY_FUNCTION__, aspect));
 141                 break;
 142         }
 143     }
 144
 145     /* Initial lock is required */
 146     if (initial == NULL)
 147     {
 148         return NULL;
 149     }
 150
 151     /* obtain volume's name from the lock */
 152     if (!NameFromLock(initial, volname, sizeof(volname))) {
 153         SetIoErr(ERROR_DEVICE_NOT_MOUNTED);
 154         return NULL;
 155     }
 156     int volname_len = strlen(volname);
 157     if ((volicon = AllocVec(volname_len + 5, MEMF_CLEAR)) == NULL)
 158     {
 159         SetIoErr(ERROR_DEVICE_NOT_MOUNTED);
 160         return NULL;
 161     }
 162     strcpy(volicon, volname);
 163     strcat(volicon, "disk");
 164     volname[strlen(volname)-1] = '\0';
 165     D(bug("[DiskInfo] %s: Volume '%s'\n", __PRETTY_FUNCTION__, volname));
 166
 167     /* find the volumes doslist information .. */
 168     IPTR volunit = 0;
 169     filesystem = _(MSG_UNKNOWN);
 170     dl = LockDosList(LDF_VOLUMES|LDF_READ);
 171     if (dl) {
 172         dn = FindDosEntry(dl, volname, LDF_VOLUMES);
 173         if (dn) {
 174             ULONG i;
 175
 176             volunit = (IPTR)dn->dol_Ext.dol_AROS.dol_Unit;
 177
 178             D(bug("[DiskInfo] %s: Volume's unit @ %p\n", __PRETTY_FUNCTION__, volunit));
 179
 180             if (dn->dol_Task != NULL)
 181             {
 182                 handlertype = _(MSG_PACKETDEVICE);
 183             }
 184             else if (dn->dol_Ext.dol_AROS.dol_Device != NULL)
 185             {
 186                 handlertype = _(MSG_IOFSDEVICE);
 187             }
 188
 189             disktype = dn->dol_misc.dol_volume.dol_DiskType;
 190             for (i = 0; i < sizeof(dt) / sizeof(LONG); ++i)
 191             {
 192                 if (disktype == dt[i])
 193                 {
 194                     fstype = disktypelist[i];
 195                     fshandler = dn->dol_Ext.dol_AROS.dol_Device->dd_Library.lib_Node.ln_Name;
 196                     disktypefound = TRUE;
 197                     break;
 198                 }
 199             }
 200             D(bug("[DiskInfo] %s: Disk Type: %s\n", __PRETTY_FUNCTION__, filesystem));
 201         }
 202         UnLockDosList(LDF_VOLUMES|LDF_READ);
 203     }
 204     /* If we know the volumes unit - find its device information .. */
 205     if (volunit != 0)
 206     {
 207         dl = LockDosList(LDF_DEVICES|LDF_READ);
 208         if (dl) {
 209             while((dl = NextDosEntry(dl, LDF_DEVICES)))
 210             {
 211                 if ((IPTR)dl->dol_Ext.dol_AROS.dol_Unit == volunit)
 212                 {
 213                     struct FileSysStartupMsg *fsstartup = (struct FileSysStartupMsg *)BADDR(dl->dol_misc.dol_handler.dol_Startup);
 214                     dosdevname = (UBYTE*)AROS_BSTR_ADDR(dl->dol_Name);
 215                     fshandler = (UBYTE*)AROS_BSTR_ADDR(dl->dol_misc.dol_handler.dol_Handler);
 216
 217                     D(bug("[DiskInfo] %s: Found Volumes device @ %p, '%s'\n", __PRETTY_FUNCTION__, dl, dosdevname));
 218                     if (fsstartup != NULL)
 219                     {
 220                         deviceinfo = AllocVec(strlen((UBYTE*)AROS_BSTR_ADDR(fsstartup->fssm_Device)) + (fsstartup->fssm_Unit/10 + 1) + 7, MEMF_CLEAR);
 221                         sprintf(deviceinfo,"%s %s %d", (UBYTE*)AROS_BSTR_ADDR(fsstartup->fssm_Device), _(MSG_UNIT), fsstartup->fssm_Unit);
 222                     }
 223                     D(bug("[DiskInfo] %s: Handler '%s'\n", __PRETTY_FUNCTION__, fshandler));
 224                     break;
 225                 }
 226             }
 227             UnLockDosList(LDF_VOLUMES|LDF_READ);
 228         }
 229     }
 230
 231     if (fstype && fshandler)
 232     {
 233         filesystem = AllocVec(strlen(fstype) + strlen(fshandler) + 4, MEMF_CLEAR);
 234         sprintf(filesystem, "%s (%s)", fstype, fshandler);
 235     }
 236
 237     volname[strlen(volname)] = ':';
 238
 239     /* Extract volume info from InfoData */
 240     if (Info(initial, &id) == DOSTRUE)
 241     {
 242         if (!disktypefound) /* Workaround for FFS-Intl having 0 as dol_DiskType */
 243         {
 244             LONG i;
 245             filesystem = _(MSG_UNKNOWN);
 246             disktype = id.id_DiskType;
 247
 248             for (i = 0; i < sizeof(dt) / sizeof(LONG); ++i)
 249             {
 250                 if (disktype == dt[i])
 251                 {
 252                     filesystem = disktypelist[i];
 253                     break;
 254                 }
 255             }
 256         }
 257
 258         FormatSize(size, id.id_NumBlocks, id.id_NumBlocks, id.id_BytesPerBlock, FALSE);
 259         percent = FormatSize(used, id.id_NumBlocksUsed, id.id_NumBlocks, id.id_BytesPerBlock, TRUE);
 260         FormatSize(free, id.id_NumBlocks - id.id_NumBlocksUsed, id.id_NumBlocks, id.id_BytesPerBlock, TRUE);
 261         sprintf(blocksize, "%d %s", id.id_BytesPerBlock, _(MSG_BYTES));
 262
 263         switch (id.id_DiskState)
 264         {
 265             case (ID_WRITE_PROTECTED):
 266                 status = _(MSG_READABLE);
 267                 break;
 268             case (ID_VALIDATING):
 269                 status = _(MSG_VALIDATING);
 270                 break;
 271             case (ID_VALIDATED):
 272                 status = _(MSG_READABLE_WRITABLE);
 273                 break;
 274             default:
 275                 status = _(MSG_UNKNOWN);
 276         }
 277     }
 278
 279     /* Create application and window objects -------------------------------*/
 280     self = (Object *) DoSuperNewTags
 281     (
 282         CLASS, self, NULL,
 283
 284         MUIA_Application_Title, __(MSG_TITLE),
 285         MUIA_Application_Version, (IPTR) "$VER: DiskInfo 0.5 ("ADATE") ©2006-2009 AROS Dev Team",
 286         MUIA_Application_Copyright, __(MSG_COPYRIGHT),
 287         MUIA_Application_Author, __(MSG_AUTHOR),
 288         MUIA_Application_Description, __(MSG_DESCRIPTION),
 289         MUIA_Application_Base, (IPTR) "DISKINFO",
 290         SubWindow, (IPTR) (window = (Object *)WindowObject,
 291             MUIA_Window_Title, (IPTR) volname,
 292             MUIA_Window_Activate,    TRUE,
 293             MUIA_Window_NoMenus,     TRUE,
 294             MUIA_Window_CloseGadget, TRUE,
 295
 296             WindowContents, (IPTR) VGroup,
 297                 Child, (IPTR) HGroup,
 298                     Child, (IPTR) VGroup,
 299                         Child, HVSpace,
 300                         Child, (IPTR) HGroup,
 301                             Child, HVSpace,
 302                             Child, (IPTR)(voliconobj = (Object *)IconImageObject,
 303                                 MUIA_InputMode, MUIV_InputMode_Toggle,
 304                                 MUIA_IconImage_File, (IPTR) volicon,
 305                             End),
 306                             Child, HVSpace,
 307                         End,
 308                         Child, HVSpace,
 309                     End,
 310                     Child, (IPTR) (grp = (Object *)VGroup,
 311                         Child, HVSpace,
 312                         Child, (IPTR) ColGroup(2),
 313 #warning "TODO: Build this list only when data is realy available, and localise"
 314                             Child, (IPTR) TextObject,
 315                                 MUIA_Text_PreParse, (IPTR) "\33r",
 316                                 MUIA_Text_Contents, (IPTR) __(MSG_DOSDEVICE),
 317                             End,
 318                             Child, (IPTR) TextObject,
 319                                 MUIA_Text_PreParse, (IPTR) "\33l",
 320                                 MUIA_Text_Contents, (IPTR) dosdevname,
 321                             End,
 322                             Child, (IPTR) TextObject,
 323                                 MUIA_Text_PreParse, (IPTR) "\33r",
 324                                 MUIA_Text_Contents, (IPTR) __(MSG_DEVICEINFO),
 325                             End,
 326                             Child, (IPTR) TextObject,
 327                                 MUIA_Text_PreParse, (IPTR) "\33l",
 328                                 MUIA_Text_Contents, (IPTR) deviceinfo,
 329                             End,
 330                             Child, (IPTR) TextObject,
 331                                 MUIA_Text_PreParse, (IPTR) "\33r",
 332                                 MUIA_Text_Contents, (IPTR) __(MSG_FILESYSTEM),
 333                             End,
 334                             Child, (IPTR) TextObject,
 335                                 MUIA_Text_PreParse, (IPTR) "\33I[6:24] \33l",
 336                                 MUIA_Text_Contents, (IPTR) filesystem,
 337                             End,
 338                             Child, (IPTR) HVSpace,
 339                             Child, (IPTR) TextObject,
 340                                 MUIA_Text_PreParse, (IPTR) "\33l",
 341                                 MUIA_Text_Contents, (IPTR) handlertype,
 342                             End,
 343                         End,
 344                         Child, HVSpace,
 345                     End),
 346                     Child, HVSpace,
 347                 End,
 348                 Child, (IPTR) VGroup,
 349                     Child, (IPTR) HGroup,
 350                         MUIA_Weight, 100,
 351                         GroupFrame,
 352                         Child, HVSpace,
 353                         Child, (IPTR) ColGroup(2),
 354                             Child, (IPTR) TextObject,
 355                                 MUIA_Text_PreParse, (IPTR) "\33r",
 356                                 MUIA_Text_Contents, __(MSG_NAME),
 357                             End,
 358                             Child, (IPTR)(volnameobj = (Object *)TextObject, TextFrame,
 359                                 MUIA_Background, MUII_TextBack,
 360                                 MUIA_Text_PreParse, (IPTR) "\33b\33l",
 361                                 MUIA_Text_Contents, (IPTR) volname,
 362                             End),
 363                             Child, (IPTR) VGroup,
 364                                 Child, (IPTR) TextObject, TextFrame,
 365                                     MUIA_FramePhantomHoriz, (IPTR)TRUE,
 366                                     MUIA_Text_PreParse, (IPTR) "\33r",
 367                                     MUIA_Text_Contents, __(MSG_SIZE),
 368                                 End,
 369                                 Child, (IPTR) TextObject, TextFrame,
 370                                     MUIA_FramePhantomHoriz, (IPTR)TRUE,
 371                                     MUIA_Text_PreParse, (IPTR) "\33r",
 372                                     MUIA_Text_Contents, __(MSG_USED),
 373                                 End,
 374                                 Child, (IPTR) TextObject, TextFrame,
 375                                     MUIA_FramePhantomHoriz, (IPTR)TRUE,
 376                                     MUIA_Text_PreParse, (IPTR) "\33r",
 377                                     MUIA_Text_Contents, __(MSG_FREE),
 378                                 End,
 379                             End,
 380                             Child, (IPTR) HGroup,
 381                                 Child, (IPTR) VGroup,
 382                                     Child, (IPTR) TextObject, TextFrame,
 383                                         MUIA_Background, MUII_TextBack,
 384                                         MUIA_Text_PreParse, (IPTR) "\33l",
 385                                         MUIA_Text_Contents, (IPTR) size,
 386                                     End,
 387                                     Child, (IPTR)(volusedobj = (Object *)TextObject, TextFrame,
 388                                         MUIA_Background, MUII_TextBack,
 389                                         MUIA_Text_PreParse, (IPTR) "\33l",
 390                                         MUIA_Text_Contents, (IPTR) used,
 391                                     End),
 392                                     Child, (IPTR)(volfreeobj = (Object *)TextObject, TextFrame,
 393                                         MUIA_Background, MUII_TextBack,
 394                                         MUIA_Text_PreParse, (IPTR) "\33l",
 395                                         MUIA_Text_Contents, (IPTR) free,
 396                                     End),
 397                                 End,
 398                                 Child, (IPTR)(volusegaugeobj = (Object *)GaugeObject, GaugeFrame,
 399                                     MUIA_Gauge_InfoText, "",
 400                                     MUIA_Gauge_Horiz, FALSE,
 401                                     MUIA_Gauge_Current, percent,
 402                                 End),
 403                             End,
 404                             Child, (IPTR) TextObject,
 405                                 MUIA_Text_PreParse, (IPTR) "\33r",
 406                                 MUIA_Text_Contents, __(MSG_BLOCK_SIZE),
 407                             End,
 408                             Child, (IPTR) TextObject, TextFrame,
 409                                 MUIA_Background, MUII_TextBack,
 410                                 MUIA_Text_PreParse, (IPTR) "\33l",
 411                                 MUIA_Text_Contents, (IPTR) blocksize,
 412                             End,
 413                             Child, (IPTR) TextObject,
 414                                 MUIA_Text_PreParse, (IPTR) "\33r",
 415                                 MUIA_Text_Contents, __(MSG_STATUS),
 416                             End,
 417                             Child, (IPTR) TextObject, TextFrame,
 418                                 MUIA_Background, MUII_TextBack,
 419                                 MUIA_Text_PreParse, (IPTR) "\33l",
 420                                 MUIA_Text_Contents, (IPTR) status,
 421                             End,
 422                             Child, HVSpace,
 423                             Child, HVSpace,
 424                         End,
 425                         Child, HVSpace,
 426                     End,
 427                     Child, (IPTR) (grpformat = (Object *)HGroup,
 428                         // grpformat object userlevel sensitive
 429                         Child, HVSpace,
 430                     End),
 431                     Child, HVSpace,
 432                 End,
 433             End,
 434         End),
 435         TAG_DONE);
 436
 437     /* Check if object creation succeeded */
 438     if (self == NULL)
 439         return NULL;
 440
 441     /* Store instance data -------------------------------------------------*/
 442     data = INST_DATA(CLASS, self);
 443
 444     data->dki_NotifyPort = CreateMsgPort();
 445
 446     data->dki_Window            = window;
 447
 448     data->dki_VolumeName        = volnameobj;
 449     data->dki_VolumeIcon        = voliconobj;
 450     data->dki_VolumeUseGauge    = volusegaugeobj;
 451     data->dki_VolumeUsed        = volusedobj;
 452     data->dki_VolumeFree        = volfreeobj;
 453
 454     data->dki_DOSDev            = AllocVec(strlen(dosdevname) +2, MEMF_CLEAR);
 455     sprintf(data->dki_DOSDev, "%s:", dosdevname);
 456
 457     data->dki_Aspect            = aspect;
 458
 459     /* Setup notifications -------------------------------------------------*/
 460     DoMethod( window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 461         (IPTR) self, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 462
 463     if (data->dki_NotifyPort)
 464     {
 465         /* Setup filesystem notification handler ---------------------------*/
 466         data->dki_NotifyIHN.ihn_Signals = 1UL << data->dki_NotifyPort->mp_SigBit;
 467         data->dki_NotifyIHN.ihn_Object  = self;
 468         data->dki_NotifyIHN.ihn_Method  = MUIM_DiskInfo_HandleNotify;
 469
 470         DoMethod(self, MUIM_Application_AddInputHandler, (IPTR)&data->dki_NotifyIHN);
 471
 472         data->dki_FSNotifyRequest.nr_Name                 = volname;
 473         data->dki_FSNotifyRequest.nr_Flags                = NRF_SEND_MESSAGE;
 474         data->dki_FSNotifyRequest.nr_stuff.nr_Msg.nr_Port = data->dki_NotifyPort;
 475         if (StartNotify(&data->dki_FSNotifyRequest))
 476         {
 477             D(bug("[DiskInfo] %s: FileSystem-Notification setup for '%s'\n", __PRETTY_FUNCTION__, data->dki_FSNotifyRequest.nr_Name));
 478         }
 479         else
 480         {
 481             D(bug("[DiskInfo] %s: FAILED to setup FileSystem-Notification for '%s'\n", __PRETTY_FUNCTION__, data->dki_FSNotifyRequest.nr_Name));
 482             DoMethod(self, MUIM_Application_RemInputHandler, (IPTR)&data->dki_NotifyIHN);
 483             DeleteMsgPort(data->dki_NotifyPort);
 484             data->dki_NotifyPort = NULL;
 485         }
 486     }
 487     return self;
 488 }
 489
 490 IPTR DiskInfo__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 491 {
 492     struct DiskInfo_DATA *data = INST_DATA(CLASS, self);
 493
 494     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 495
 496     if (data->dki_NotifyPort)
 497     {
 498         DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->dki_NotifyIHN);
 499
 500         EndNotify(&data->dki_FSNotifyRequest);
 501
 502         DeleteMsgPort(data->dki_NotifyPort);
 503     }
 504
 505     if (data->dki_DOSDev) FreeVec(data->dki_DOSDev);
 506
 507     return DoSuperMethodA(CLASS, self, message);
 508 }
 509
 510 IPTR DiskInfo__MUIM_Application_Execute(Class *CLASS, Object *self, Msg message)
 511 {
 512     struct DiskInfo_DATA *data = INST_DATA(CLASS, self);
 513
 514     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 515
 516     SET(data->dki_Window, MUIA_Window_Open, TRUE);
 517
 518     DoSuperMethodA(CLASS, self, message);
 519
 520     SET(data->dki_Window, MUIA_Window_Open, FALSE);
 521
 522     return (IPTR) NULL;
 523 }
 524
 525 IPTR DiskInfo__MUIM_DiskInfo_HandleNotify
 526 (
 527     Class *CLASS, Object *self, Msg message
 528 )
 529 {
 530     struct DiskInfo_DATA *data = INST_DATA(CLASS, self);
 531     struct NotifyMessage *npMessage = NULL;
 532     static struct InfoData id;
 533     BPTR fsdevlock = NULL;
 534     BOOL di_Quit = FALSE;
 535
 536     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 537
 538     if (data->dki_NotifyPort)
 539     {
 540         while ((npMessage = (struct NotifyMessage *)GetMsg(data->dki_NotifyPort)) != NULL)
 541         {
 542             D(bug("[DiskInfo] %s: FS notification recieved\n", __PRETTY_FUNCTION__));
 543
 544             if ((fsdevlock = Lock(data->dki_DOSDev, SHARED_LOCK)) != NULL)
 545             {
 546                 /* Extract volume info from InfoData */
 547                 if (Info(fsdevlock, &id) == DOSTRUE)
 548                 {
 549                     if (id.id_DiskType != ID_NO_DISK_PRESENT)
 550                     {
 551                         ULONG                       percent;
 552                         TEXT                        used[64];
 553                         TEXT                        free[64];
 554                         //TEXT                        blocksize[16];
 555
 556                         D(bug("[DiskInfo] %s: Updating Window from DOS Device '%s'\n", __PRETTY_FUNCTION__, data->dki_DOSDev));
 557
 558                         //FormatSize(size, id.id_NumBlocks, id.id_NumBlocks, id.id_BytesPerBlock, FALSE);
 559                         percent = FormatSize(used, id.id_NumBlocksUsed, id.id_NumBlocks, id.id_BytesPerBlock, TRUE);
 560                         FormatSize(free, id.id_NumBlocks - id.id_NumBlocksUsed, id.id_NumBlocks, id.id_BytesPerBlock, TRUE);
 561                         //sprintf(blocksize, "%d %s", id.id_BytesPerBlock, _(MSG_BYTES));
 562
 563                         //data->dki_VolumeName  = volnameobj;
 564                         SET(data->dki_VolumeUsed, MUIA_Text_Contents, used);
 565                         SET(data->dki_VolumeFree, MUIA_Text_Contents, free);
 566                         SET(data->dki_VolumeUseGauge, MUIA_Gauge_Current, percent);
 567                     }
 568                     else
 569                     {
 570                         D(bug("[DiskInfo] %s: Volume no longer available on DOS Device '%s'\n", __PRETTY_FUNCTION__, data->dki_DOSDev));
 571                         di_Quit = TRUE;
 572                     }
 573                 }
 574                 else
 575                 {
 576                     D(bug("[DiskInfo] %s: Failed to obtain Info for DOS Device '%s'\n", __PRETTY_FUNCTION__, data->dki_DOSDev));
 577                     di_Quit = TRUE;
 578                 }
 579
 580                 UnLock(fsdevlock);
 581             }
 582             else
 583             {
 584                 D(bug("[DiskInfo] %s: Failed to lock DOS Device '%s'\n", __PRETTY_FUNCTION__, data->dki_DOSDev));
 585                 di_Quit = TRUE;
 586             }
 587             ReplyMsg((struct Message *)npMessage);
 588         }
 589     }
 590     if (di_Quit)
 591     {
 592 #warning "TODO: set MUIV_Application_ReturnID_Quit"
 593     }
 594     return (IPTR)NULL;
 595 }
 596
 597 IPTR DiskInfo__OM_GET(Class *CLASS, Object *self, struct opGet *msg)
 598 {
 599     struct DiskInfo_DATA *data = INST_DATA(CLASS, self);
 600     IPTR retval = TRUE;
 601
 602     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 603
 604     switch(msg->opg_AttrID)
 605     {
 606         case MUIA_DiskInfo_Volname:
 607             retval = (IPTR)XGET(data->dki_VolumeName, MUIA_Text_Contents);
 608             break;
 609         case MUIA_DiskInfo_Percent:
 610             retval = (ULONG)XGET(data->dki_VolumeUseGauge, MUIA_Gauge_Current);
 611             break;
 612         case MUIA_DiskInfo_Aspect:
 613             retval = (ULONG) data->dki_Aspect;
 614             break;
 615         default:
 616             retval = DoSuperMethodA(CLASS, self, (Msg)msg);
 617             break;
 618     }
 619     return retval;
 620 }
 621
 622 ULONG DiskInfo__OM_SET(Class *CLASS, Object *self, struct opSet *msg)
 623 {
 624     struct DiskInfo_DATA *data = INST_DATA(CLASS, self);
 625     const struct TagItem *tags = msg->ops_AttrList;
 626     struct TagItem       *tag;
 627
 628     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 629
 630     while ((tag = NextTagItem((const struct TagItem **)&tags)) != NULL)
 631     {
 632         switch (tag->ti_Tag)
 633         {
 634             case MUIA_DiskInfo_Aspect:
 635                 data->dki_Aspect = tag->ti_Data;
 636                 break;
 637         }
 638     }
 639     return DoSuperMethodA(CLASS, self, (Msg)msg);
 640 }
 641
 642 /*** Dispatcher *************************************************************/
 643 BOOPSI_DISPATCHER(IPTR, DiskInfo_Dispatcher, CLASS, self, message)
 644 {
 645     switch (message->MethodID)
 646     {
 647         case OM_NEW:                            return (IPTR) DiskInfo__OM_NEW(CLASS, self, (struct opSet *) message);
 648         case OM_DISPOSE:                        return DiskInfo__OM_DISPOSE(CLASS, self, message);
 649         case OM_GET:                            return (IPTR) DiskInfo__OM_GET(CLASS, self, (struct opGet *)message);
 650         case OM_SET:                            return (IPTR) DiskInfo__OM_SET(CLASS, self, (struct opSet *)message);
 651         case MUIM_DiskInfo_HandleNotify:        return DiskInfo__MUIM_DiskInfo_HandleNotify(CLASS, self, message);
 652         case MUIM_Application_Execute:          return DiskInfo__MUIM_Application_Execute(CLASS, self, message);
 653         default:                                return DoSuperMethodA(CLASS, self, message);
 654     }
 655     return 0;
 656 }
 657 BOOPSI_DISPATCHER_END
 658
 659 /*** Setup ******************************************************************/
 660 struct MUI_CustomClass *DiskInfo_CLASS;
 661
 662 BOOL DiskInfo_Initialize()
 663 {
 664     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 665
 666     DiskInfo_CLASS = MUI_CreateCustomClass(
 667         NULL, MUIC_Application, NULL,
 668         sizeof(struct DiskInfo_DATA), DiskInfo_Dispatcher);
 669
 670     return DiskInfo_CLASS ? TRUE : FALSE;
 671 }
 672
 673 VOID DiskInfo_Deinitialize()
 674 {
 675     D(bug("[DiskInfo] %s()\n", __PRETTY_FUNCTION__));
 676
 677     if (DiskInfo_CLASS != NULL)
 678     {
 679         MUI_DeleteCustomClass(DiskInfo_CLASS);
 680     }
 681 }