workbench/libs/muimaster/classes/volumelist.c

   1 /*
   2     Copyright © 2002-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <exec/memory.h>
   9 #include <clib/alib_protos.h>
  10 #include <proto/exec.h>
  11 #include <proto/dos.h>
  12 #include <proto/intuition.h>
  13 #include <proto/utility.h>
  14 #include <proto/muimaster.h>
  15
  16 #include <string.h>
  17 #include <stdio.h>
  18
  19 #include "mui.h"
  20 #include "muimaster_intern.h"
  21 #include "support.h"
  22 #include "support_classes.h"
  23 #include "volumelist_private.h"
  24
  25 extern struct Library *MUIMasterBase;
  26
  27
  28 static void printSize(STRPTR string, size_t bufsize, UQUAD size)
  29 {
  30     char unit = 'B';
  31
  32     if (size >= 9999999999ULL)
  33     {
  34         size = size >> 30;
  35         unit = 'G';
  36     }
  37     else if (size >= 9999999UL)
  38     {
  39         size = size >> 20;
  40         unit = 'M';
  41     }
  42     else if (size > 9999)
  43     {
  44         size = size >> 10;
  45         unit = 'K';
  46     }
  47
  48     snprintf(string, bufsize, "%u%c", (ULONG)size, unit);
  49     string[bufsize - 1] = '\0';
  50 }
  51
  52 AROS_UFH3S(APTR, construct_func,
  53 AROS_UFHA(struct Hook *, hook, A0),
  54 AROS_UFHA(APTR, pool, A2),
  55 AROS_UFHA(struct Volumelist_Entry *, entry, A1))
  56 {
  57     AROS_USERFUNC_INIT
  58
  59     struct Volumelist_Entry *new;
  60
  61     if ((new = AllocPooled(pool, sizeof(*new))))
  62     {
  63         *new = *entry;
  64     }
  65     return new;
  66
  67     AROS_USERFUNC_EXIT
  68 }
  69
  70 AROS_UFH3S(void, destruct_func,
  71 AROS_UFHA(struct Hook *, hook, A0),
  72 AROS_UFHA(APTR, pool, A2),
  73 AROS_UFHA(struct Volumelist_Entry *, entry, A1))
  74 {
  75     AROS_USERFUNC_INIT
  76
  77     FreePooled(pool, entry, sizeof(struct Volumelist_Entry));
  78
  79     AROS_USERFUNC_EXIT
  80 }
  81
  82 AROS_UFH3S(LONG, display_func,
  83 AROS_UFHA(struct Hook *, hook, A0),
  84 AROS_UFHA(char **, array, A2),
  85 AROS_UFHA(struct Volumelist_Entry *, entry, A1))
  86 {
  87     AROS_USERFUNC_INIT
  88
  89     /* MUI: logo | devicename | %-used | bytes free | bytes used */
  90
  91     if (entry)
  92     {
  93         if (entry->type == DLT_DEVICE)
  94         {
  95             *array++ = "\33I[6:24]";
  96         }
  97         else if (entry->type == DLT_VOLUME)
  98         {
  99             *array++ = "\33I[6:26]";
 100         }
 101         else
 102         {
 103             *array++ = "\33I[6:29]";
 104         }
 105
 106         *array++ = entry->name;
 107         *array++ = entry->full;
 108         *array++ = entry->free;
 109         *array   = entry->used;
 110     }
 111     else
 112     {
 113         *array++ = "";
 114         *array++ = "Name";
 115         *array++ = "full";
 116         *array++ = "free";
 117         *array   = "used";
 118     }
 119
 120     return 0;
 121
 122     AROS_USERFUNC_EXIT
 123 }
 124
 125
 126 IPTR Volumelist__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 127 {
 128     struct DosList *dl, *actdl;
 129
 130     STRPTR format = (STRPTR)GetTagData(MUIA_List_Format, 0, msg->ops_AttrList);
 131
 132     obj = (Object *)DoSuperNewTags
 133     (
 134         cl, obj, NULL,
 135         MUIA_List_Format, format
 136             ? TAG_IGNORE
 137             : (IPTR)",,P=\33r,P=\33r,P=\33r",
 138         TAG_MORE, (IPTR) msg->ops_AttrList
 139     );
 140
 141     if (obj)
 142     {
 143         struct Volumelist_DATA *data = INST_DATA(cl, obj);
 144
 145         data->construct_hook.h_Entry = (HOOKFUNC)construct_func;
 146         data->destruct_hook.h_Entry  = (HOOKFUNC)destruct_func;
 147         data->display_hook.h_Entry   = (HOOKFUNC)display_func;
 148
 149         SetAttrs(obj, MUIA_List_ConstructHook, (IPTR)&data->construct_hook,
 150                       MUIA_List_DestructHook,  (IPTR)&data->destruct_hook,
 151                       MUIA_List_DisplayHook, (IPTR)&data->display_hook,
 152                       TAG_DONE);
 153
 154         dl = LockDosList(LDF_READ | LDF_VOLUMES | LDF_ASSIGNS | LDF_DEVICES);
 155
 156         actdl = dl;
 157         while((actdl = NextDosEntry(actdl, LDF_DEVICES)))
 158         {
 159             struct Volumelist_Entry entry;
 160
 161             entry.full[0] = '\0';
 162             entry.free[0] = '\0';
 163             entry.used[0] = '\0';
 164
 165             entry.type = DLT_DEVICE;
 166         #ifdef __AROS__
 167             strncpy(entry.name, actdl->dol_Ext.dol_AROS.dol_DevName, sizeof(entry.name));
 168         #else
 169             #warning "FIXME: AmigaOS: get device name"
 170             strncpy(entry.name, "???", sizeof(entry.name));
 171         #endif
 172             entry.name[sizeof(entry.name) - 2] = '\0';
 173             strcat(entry.name, ":");
 174
 175             DoMethod(obj, MUIM_List_InsertSingle, (IPTR)&entry, MUIV_List_Insert_Bottom);
 176         }
 177
 178         actdl = dl;
 179         while((actdl = NextDosEntry(actdl, LDF_VOLUMES)))
 180         {
 181             struct Volumelist_Entry entry;
 182             struct InfoData diskinfo;
 183             BPTR lock;
 184             UQUAD free;
 185             UQUAD used;
 186
 187             entry.full[0] = '\0';
 188             entry.free[0] = '\0';
 189             entry.used[0] = '\0';
 190
 191             entry.type = DLT_VOLUME;
 192         #ifdef __AROS__
 193             strncpy(entry.name, actdl->dol_Ext.dol_AROS.dol_DevName, sizeof(entry.name));
 194         #else
 195             #warning "FIXME: AmigaOS: get device name"
 196             strncpy(entry.name, "???", sizeof(entry.name));
 197         #endif
 198             entry.name[sizeof(entry.name) - 2] = '\0';
 199             strcat(entry.name, ":");
 200
 201             if ((lock = Lock(entry.name, SHARED_LOCK)) != NULL)
 202             {
 203                 if (Info(lock, &diskinfo) != DOSFALSE)
 204                 {
 205                     snprintf
 206                     (
 207                         entry.full,
 208                         sizeof(entry.full),
 209                         "%d%%",
 210                         100 * diskinfo.id_NumBlocksUsed / diskinfo.id_NumBlocks
 211                     );
 212                     entry.full[sizeof(entry.full) - 1] = '\0';
 213
 214                     used = (UQUAD)diskinfo.id_NumBlocksUsed * diskinfo.id_BytesPerBlock;
 215                     free = (UQUAD)diskinfo.id_NumBlocks * diskinfo.id_BytesPerBlock - used;
 216                     printSize(entry.free, sizeof entry.free, free);
 217                     printSize(entry.used, sizeof entry.used, used);
 218                 }
 219                 UnLock(lock);
 220             }
 221
 222             DoMethod(obj, MUIM_List_InsertSingle, (IPTR)&entry, MUIV_List_Insert_Bottom);
 223         }
 224
 225         actdl = dl;
 226         while((actdl = NextDosEntry(actdl, LDF_ASSIGNS)))
 227         {
 228             struct Volumelist_Entry entry;
 229
 230             entry.full[0] = '\0';
 231             entry.free[0] = '\0';
 232             entry.used[0] = '\0';
 233
 234             entry.type = DLT_DIRECTORY;
 235         #ifdef __AROS__
 236             strncpy(entry.name, actdl->dol_Ext.dol_AROS.dol_DevName, sizeof(entry.name));
 237         #else
 238             #warning "FIXME: AmigaOS: get assign name"
 239             strncpy(entry.name, "???", sizeof(entry.name));
 240         #endif
 241             entry.name[sizeof(entry.name) - 2] = '\0';
 242             strcat(entry.name, ":");
 243
 244             DoMethod(obj, MUIM_List_InsertSingle, (IPTR)&entry, MUIV_List_Insert_Bottom);
 245         }
 246
 247         UnLockDosList(LDF_READ | LDF_VOLUMES | LDF_ASSIGNS | LDF_DEVICES);
 248     }
 249
 250     return (IPTR)obj;
 251 }
 252
 253
 254 #if ZUNE_BUILTIN_VOLUMELIST
 255 BOOPSI_DISPATCHER(IPTR, Volumelist_Dispatcher, cl, obj, msg)
 256 {
 257     switch (msg->MethodID)
 258     {
 259         case OM_NEW: return Volumelist__OM_NEW(cl, obj, (struct opSet *)msg);
 260
 261         default:     return DoSuperMethodA(cl, obj, msg);
 262     }
 263 }
 264 BOOPSI_DISPATCHER_END
 265
 266 const struct __MUIBuiltinClass _MUI_Volumelist_desc =
 267 {
 268     MUIC_Volumelist,
 269     MUIC_List,
 270     sizeof(struct Volumelist_DATA),
 271     (void*)Volumelist_Dispatcher
 272 };
 273 #endif /* ZUNE_BUILTIN_VOLUMELIST */