workbench/libs/muimaster/classes/volumelist.c

   1 /*
   2     Copyright © 2002-2011, 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", (unsigned int)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,
 127     struct opSet *msg)
 128 {
 129     struct DosList *dl, *actdl;
 130
 131     STRPTR format =
 132         (STRPTR) GetTagData(MUIA_List_Format, 0, msg->ops_AttrList);
 133
 134     obj = (Object *)DoSuperNewTags
 135     (
 136         cl, obj, NULL,
 137         format ? TAG_IGNORE : MUIA_List_Format, (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,
 150             (IPTR) & data->construct_hook, MUIA_List_DestructHook,
 151             (IPTR) & data->destruct_hook, MUIA_List_DisplayHook,
 152             (IPTR) & data->display_hook, TAG_DONE);
 153
 154         dl = LockDosList(LDF_READ | LDF_VOLUMES | LDF_ASSIGNS |
 155             LDF_DEVICES);
 156
 157         actdl = dl;
 158         while ((actdl = NextDosEntry(actdl, LDF_DEVICES)))
 159         {
 160             struct Volumelist_Entry entry;
 161
 162             entry.full[0] = '\0';
 163             entry.free[0] = '\0';
 164             entry.used[0] = '\0';
 165
 166             entry.type = DLT_DEVICE;
 167
 168             strncpy(entry.name, AROS_BSTR_ADDR(actdl->dol_Name),
 169                 sizeof(entry.name));
 170             entry.name[sizeof(entry.name) - 2] = '\0';
 171             strcat(entry.name, ":");
 172
 173             DoMethod(obj, MUIM_List_InsertSingle, (IPTR) & entry,
 174                 MUIV_List_Insert_Bottom);
 175         }
 176
 177         actdl = dl;
 178         while ((actdl = NextDosEntry(actdl, LDF_VOLUMES)))
 179         {
 180             struct Volumelist_Entry entry;
 181             struct InfoData diskinfo;
 182             BPTR lock;
 183             UQUAD free;
 184             UQUAD used;
 185
 186             entry.full[0] = '\0';
 187             entry.free[0] = '\0';
 188             entry.used[0] = '\0';
 189
 190             entry.type = DLT_VOLUME;
 191
 192             strncpy(entry.name, AROS_BSTR_ADDR(actdl->dol_Name),
 193                 sizeof(entry.name));
 194             entry.name[sizeof(entry.name) - 2] = '\0';
 195             strcat(entry.name, ":");
 196
 197             if ((lock = Lock(entry.name, SHARED_LOCK)) != BNULL)
 198             {
 199                 if (Info(lock, &diskinfo) != DOSFALSE)
 200                 {
 201                     snprintf
 202                         (entry.full,
 203                         sizeof(entry.full),
 204                         "%ld%%",
 205                         (long)(100 * diskinfo.id_NumBlocksUsed /
 206                             diskinfo.id_NumBlocks));
 207                     entry.full[sizeof(entry.full) - 1] = '\0';
 208
 209                     used =
 210                         (UQUAD) diskinfo.id_NumBlocksUsed *
 211                         diskinfo.id_BytesPerBlock;
 212                     free =
 213                         (UQUAD) diskinfo.id_NumBlocks *
 214                         diskinfo.id_BytesPerBlock - used;
 215                     printSize(entry.free, sizeof entry.free, free);
 216                     printSize(entry.used, sizeof entry.used, used);
 217                 }
 218                 UnLock(lock);
 219             }
 220
 221             DoMethod(obj, MUIM_List_InsertSingle, (IPTR) & entry,
 222                 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
 236             strncpy(entry.name, AROS_BSTR_ADDR(actdl->dol_Name),
 237                 sizeof(entry.name));
 238             entry.name[sizeof(entry.name) - 2] = '\0';
 239             strcat(entry.name, ":");
 240
 241             DoMethod(obj, MUIM_List_InsertSingle, (IPTR) & entry,
 242                 MUIV_List_Insert_Bottom);
 243         }
 244
 245         UnLockDosList(LDF_READ | LDF_VOLUMES | LDF_ASSIGNS | LDF_DEVICES);
 246     }
 247
 248     return (IPTR) obj;
 249 }
 250
 251
 252 #if ZUNE_BUILTIN_VOLUMELIST
 253 BOOPSI_DISPATCHER(IPTR, Volumelist_Dispatcher, cl, obj, msg)
 254 {
 255     switch (msg->MethodID)
 256     {
 257     case OM_NEW:
 258         return Volumelist__OM_NEW(cl, obj, (struct opSet *)msg);
 259
 260     default:
 261         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 */