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

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