workbench/libs/muimaster/classes/dirlist.c

   1 /*
   2     Copyright © 2002-2006, 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 <dos/exall.h>
  10 #include <dos/datetime.h>
  11 #include <clib/alib_protos.h>
  12 #include <proto/exec.h>
  13 #include <proto/dos.h>
  14 #include <proto/intuition.h>
  15 #include <proto/utility.h>
  16 #include <proto/muimaster.h>
  17
  18 #include <string.h>
  19 #include <stdio.h>
  20
  21 #include "mui.h"
  22 #include "muimaster_intern.h"
  23 #include "support.h"
  24 #include "support_classes.h"
  25 #include "dirlist_private.h"
  26
  27 extern struct Library *MUIMasterBase;
  28
  29 static APTR construct_func(struct Hook *hook, APTR pool, struct Dirlist_Entry *entry)
  30 {
  31     struct Dirlist_Entry *new;
  32
  33     if ((new = AllocPooled(pool, sizeof(*new))))
  34     {
  35         *new = *entry;
  36     }
  37     return new;
  38 }
  39
  40 static void destruct_func(struct Hook *hook, APTR pool, struct Dirlist_Entry *entry)
  41 {
  42     FreePooled(pool, entry, sizeof(struct Dirlist_Entry));
  43 }
  44
  45 static LONG display_func(struct Hook *hook, char **array, struct Dirlist_Entry *entry)
  46 {
  47     struct Dirlist_DATA *data = hook->h_Data;
  48     struct DateTime      dt;
  49
  50     /* MUI: name | size | Date  | Time  | Protection | Comment */
  51
  52     *array++ = entry->fib.fib_FileName;
  53
  54     if (entry->fib.fib_DirEntryType > 0)
  55     {
  56         *array++ = "\33r\33I[6:22]";
  57     }
  58     else
  59     {
  60         snprintf(data->size_string, sizeof(data->size_string), "\33r%ld", entry->fib.fib_Size);
  61         *array++ = data->size_string;
  62     }
  63
  64     dt.dat_Stamp   = entry->fib.fib_Date;
  65     dt.dat_Format  = FORMAT_DOS;
  66     dt.dat_Flags   = 0;
  67     dt.dat_StrDay  = NULL;
  68     dt.dat_StrDate = data->date_string;
  69     dt.dat_StrTime = data->time_string;
  70
  71     DateToStr(&dt);
  72
  73     *array++ = data->date_string;
  74     *array++ = data->time_string;
  75
  76     data->prot_string[0] = (entry->fib.fib_Protection & FIBF_SCRIPT)  ? 's' : '-';
  77     data->prot_string[1] = (entry->fib.fib_Protection & FIBF_PURE)    ? 'p' : '-';
  78     data->prot_string[2] = (entry->fib.fib_Protection & FIBF_ARCHIVE) ? 'a' : '-';
  79     data->prot_string[3] = (entry->fib.fib_Protection & FIBF_READ)    ? '-' : 'r';
  80     data->prot_string[4] = (entry->fib.fib_Protection & FIBF_WRITE)   ? '-' : 'w';
  81     data->prot_string[5] = (entry->fib.fib_Protection & FIBF_EXECUTE) ? '-' : 'e';
  82     data->prot_string[6] = (entry->fib.fib_Protection & FIBF_DELETE ) ? '-' : 'd';
  83     data->prot_string[7] = '\0';
  84
  85     *array++ = data->prot_string;
  86     *array   = entry->fib.fib_Comment;
  87
  88     return 0;
  89 }
  90
  91 IPTR Dirlist__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg);
  92
  93 IPTR Dirlist__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  94 {
  95     obj = (Object *)DoSuperNewTags
  96     (
  97         cl, obj, NULL,
  98         MUIA_List_Format, (IPTR)",,,,,",
  99         TAG_MORE, (IPTR) msg->ops_AttrList
 100     );
 101
 102     if (obj)
 103     {
 104         struct Dirlist_DATA *data = INST_DATA(cl, obj);
 105
 106         data->status = MUIV_Dirlist_Status_Invalid;
 107
 108         data->construct_hook.h_Entry    = HookEntry;
 109         data->construct_hook.h_SubEntry = (HOOKFUNC)construct_func;
 110         data->destruct_hook.h_Entry     = HookEntry;
 111         data->destruct_hook.h_SubEntry  = (HOOKFUNC)destruct_func;
 112         data->display_hook.h_Entry      = HookEntry;
 113         data->display_hook.h_SubEntry   = (HOOKFUNC)display_func;
 114         data->display_hook.h_Data       = data;
 115
 116         SetAttrs(obj, MUIA_List_ConstructHook, (IPTR)&data->construct_hook,
 117                       MUIA_List_DestructHook,  (IPTR)&data->destruct_hook,
 118                       MUIA_List_DisplayHook, (IPTR)&data->display_hook,
 119                       TAG_DONE);
 120
 121         Dirlist__OM_SET(cl, obj, msg);
 122     }
 123
 124     return (IPTR)obj;
 125 }
 126
 127 IPTR Dirlist__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 128 {
 129     struct Dirlist_DATA *data = INST_DATA(cl, obj);
 130
 131     FreeVec(data->path);
 132
 133     return DoSuperMethodA(cl, obj, msg);
 134 }
 135
 136 static void ReadDirectory(Object *obj, struct Dirlist_DATA *data)
 137 {
 138     struct FileInfoBlock *fib;
 139     BPTR                  lock;
 140
 141     if ((fib = AllocDosObject(DOS_FIB, NULL)))
 142     {
 143         if ((lock = Lock(data->directory, SHARED_LOCK)))
 144         {
 145             BOOL success;
 146
 147             success = Examine(lock, fib);
 148
 149             if (success && (fib->fib_DirEntryType > 0))
 150             {
 151                 for(;;)
 152                 {
 153                     BOOL isdir;
 154
 155                     success = ExNext(lock, fib);
 156
 157                     if (!success)
 158                     {
 159                         if (IoErr() == ERROR_NO_MORE_ENTRIES) success = TRUE;
 160
 161                         break;
 162                     }
 163
 164                     isdir = (fib->fib_DirEntryType > 0);
 165
 166                     if (data->filterhook)
 167                     {
 168                         struct ExAllData ead = {0};
 169
 170                         ead.ed_Name    = fib->fib_FileName;
 171                         ead.ed_Type    = fib->fib_DirEntryType;
 172                         ead.ed_Size    = fib->fib_Size;
 173                         ead.ed_Prot    = fib->fib_Protection;
 174                         ead.ed_Days    = fib->fib_Date.ds_Days;
 175                         ead.ed_Mins    = fib->fib_Date.ds_Minute;
 176                         ead.ed_Ticks   = fib->fib_Date.ds_Tick;
 177                         ead.ed_Comment = fib->fib_Comment;
 178
 179                         if (!CallHookPkt(data->filterhook, obj, &ead)) continue;
 180                     }
 181                     else
 182                     {
 183                         if (isdir && data->filesonly) continue;
 184                         if (!isdir && data->drawersonly) continue;
 185
 186                         if (data->rejecticons)
 187                         {
 188                             WORD len = strlen(fib->fib_FileName);
 189
 190                             if (len >= 5)
 191                             {
 192                                 if (stricmp(fib->fib_FileName + len - 5, ".info") == 0) continue;
 193                             }
 194                         }
 195
 196                         if (!isdir || data->filterdrawers)
 197                         {
 198                             if (data->acceptpattern)
 199                             {
 200                                 if (!MatchPatternNoCase(data->acceptpattern, fib->fib_FileName)) continue;
 201                             }
 202
 203                             if (data->rejectpattern)
 204                             {
 205                                 if (MatchPatternNoCase(data->rejectpattern, fib->fib_FileName)) continue;
 206                             }
 207                         }
 208
 209                         if (isdir)
 210                         {
 211                             set(obj, MUIA_Dirlist_NumDrawers, ++data->numdrawers);
 212                         }
 213                         else
 214                         {
 215                             set(obj, MUIA_Dirlist_NumFiles, ++data->numfiles);
 216                             set(obj, MUIA_Dirlist_NumBytes, data->numbytes + fib->fib_Size);
 217                         }
 218
 219                         DoMethod(obj, MUIM_List_InsertSingle, (IPTR)fib, MUIV_List_Insert_Bottom);
 220
 221                     } /* no filterhook */
 222
 223                 } /* for(;;) */
 224
 225                 set(obj, MUIA_Dirlist_Status, MUIV_Dirlist_Status_Valid);
 226
 227
 228             } /* if (success && (fib->fib_DirEntryType > 0)) */
 229
 230             UnLock(lock);
 231
 232         } /* if ((lock = Lock(data->directory, SHARED_LOCK))) */
 233         FreeDosObject(DOS_FIB, fib);
 234
 235     } /* if ((fib = AllocDosObject(DOS_FIB, NULL))) */
 236 }
 237
 238 IPTR Dirlist__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 239 {
 240     struct Dirlist_DATA *data = INST_DATA(cl, obj);
 241     struct TagItem      *tag, *tags;
 242     BOOL                 directory_changed = FALSE;
 243
 244     for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
 245     {
 246         IPTR tidata = tag->ti_Data;
 247
 248         switch (tag->ti_Tag)
 249         {
 250
 251             case MUIA_Dirlist_AcceptPattern:
 252                 data->acceptpattern = (STRPTR)tidata;
 253                 break;
 254
 255             case MUIA_Dirlist_Directory:
 256                 data->directory = (STRPTR)tidata;
 257                 directory_changed = TRUE;
 258                 break;
 259
 260             case MUIA_Dirlist_DrawersOnly:
 261                 data->drawersonly = tidata ? TRUE : FALSE;
 262                 break;
 263
 264             case MUIA_Dirlist_FilesOnly:
 265                 data->filesonly = tidata ? TRUE : FALSE;
 266                 break;
 267
 268             case MUIA_Dirlist_FilterDrawers:
 269                 data->filterdrawers = tidata ? TRUE : FALSE;
 270                 break;
 271
 272             case MUIA_Dirlist_FilterHook:
 273                 data->filterhook = (struct Hook *)tidata;
 274                 break;
 275
 276             case MUIA_Dirlist_MultiSelDirs:
 277                 data->multiseldirs = tidata ? TRUE : FALSE;
 278                 break;
 279
 280             case MUIA_Dirlist_RejectIcons:
 281                 data->rejecticons = tidata ? TRUE : FALSE;
 282                 break;
 283
 284             case MUIA_Dirlist_RejectPattern:
 285                 data->rejectpattern = (STRPTR)tidata;
 286                 break;
 287
 288             case MUIA_Dirlist_SortDirs:
 289                 data->sortdirs = tidata ? TRUE : FALSE;
 290                 break;
 291
 292             case MUIA_Dirlist_SortHighLow:
 293                 data->sorthighlow = tidata ? TRUE : FALSE;
 294                 break;
 295
 296             case MUIA_Dirlist_SortType:
 297                 data->sorttype = tidata;
 298                 break;
 299
 300             case MUIA_Dirlist_Status:
 301                 data->status = tidata;
 302                 break;
 303
 304         } /* switch (tag->ti_Tag) */
 305
 306     } /* for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); ) */
 307
 308     if (directory_changed)
 309     {
 310         if (data->status == MUIV_Dirlist_Status_Valid)
 311         {
 312             DoMethod(obj, MUIM_List_Clear);
 313
 314             SetAttrs(obj, MUIA_Dirlist_Status    , MUIV_Dirlist_Status_Invalid,
 315                           MUIA_Dirlist_NumBytes  , 0                          ,
 316                           MUIA_Dirlist_NumFiles  , 0                          ,
 317                           MUIA_Dirlist_NumDrawers, 0                          ,
 318                           TAG_DONE                                            );
 319
 320         }
 321
 322         if (data->directory)
 323         {
 324             ReadDirectory(obj, data);
 325         }
 326
 327     }
 328
 329     return (msg->MethodID == OM_SET) ? DoSuperMethodA(cl, obj, (Msg)msg) : 0;
 330
 331 }
 332
 333 IPTR Dirlist__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 334 {
 335     struct Dirlist_DATA *data = INST_DATA(cl, obj);
 336
 337     #define STORE *(msg->opg_Storage)
 338
 339     switch(msg->opg_AttrID)
 340     {
 341         case MUIA_Dirlist_AcceptPattern:
 342             STORE = (IPTR)data->acceptpattern;
 343             return 1;
 344
 345         case MUIA_Dirlist_Directory:
 346             STORE = (IPTR)data->directory;
 347             return 1;
 348
 349         case MUIA_Dirlist_DrawersOnly:
 350             STORE = data->drawersonly;
 351             return 1;
 352
 353         case MUIA_Dirlist_FilesOnly:
 354             STORE = data->filesonly;
 355             return 1;
 356
 357         case MUIA_Dirlist_FilterDrawers:
 358             STORE = data->filterdrawers;
 359             return 1;
 360
 361         case MUIA_Dirlist_FilterHook:
 362             STORE = (IPTR)data->filterhook;
 363             return 1;
 364
 365         case MUIA_Dirlist_MultiSelDirs:
 366             STORE = data->multiseldirs;
 367             return 1;
 368
 369         case MUIA_Dirlist_NumBytes:
 370             STORE = data->numbytes;
 371             return 1;
 372
 373         case MUIA_Dirlist_NumFiles:
 374             STORE = data->numfiles;
 375             return 1;
 376
 377         case MUIA_Dirlist_NumDrawers:
 378             STORE = data->numdrawers;
 379             return 1;
 380
 381         case MUIA_Dirlist_Path:
 382             if (data->path)
 383             {
 384                 FreeVec(data->path);
 385                 data->path = NULL;
 386             }
 387
 388             STORE = 0;
 389
 390             if (data->status == MUIV_Dirlist_Status_Valid)
 391             {
 392                 struct FileInfoBlock *fib;
 393
 394                 DoMethod(obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &fib);
 395
 396                 if (fib)
 397                 {
 398                     WORD len = strlen(fib->fib_FileName) + strlen(data->directory) + 3;
 399
 400                     data->path = AllocVec(len, MEMF_ANY);
 401                     if (data->path)
 402                     {
 403                         strcpy(data->path, data->directory);
 404                         if (AddPart(data->path, fib->fib_FileName, len))
 405                         {
 406                             STORE = (IPTR)data->path;
 407                         }
 408                     }
 409                 }
 410             }
 411             return 1;
 412
 413         case MUIA_Dirlist_RejectIcons:
 414             STORE = data->rejecticons;
 415             return 1;
 416
 417         case MUIA_Dirlist_RejectPattern:
 418             STORE = (IPTR)data->rejectpattern;
 419             return 1;
 420
 421         case MUIA_Dirlist_SortDirs:
 422             STORE = data->sortdirs;
 423             return 1;
 424
 425         case MUIA_Dirlist_SortHighLow:
 426             STORE = data->sorthighlow;
 427             return 1;
 428
 429         case MUIA_Dirlist_SortType:
 430             STORE = data->sorttype;
 431             return 1;
 432
 433         case MUIA_Dirlist_Status:
 434             STORE = data->status;
 435             return 1;
 436
 437     }
 438
 439     return DoSuperMethodA(cl, obj, (Msg)msg);
 440
 441 }
 442
 443
 444 IPTR Dirlist__MUIM_Dirlist_ReRead(struct IClass *cl, Object *obj, struct MUIP_Dirlist_ReRead *msg)
 445 {
 446     struct Dirlist_DATA *data = INST_DATA(cl, obj);
 447
 448     set(obj, MUIA_List_Quiet, TRUE);
 449     if (data->status == MUIV_Dirlist_Status_Valid)
 450     {
 451         DoMethod(obj, MUIM_List_Clear);
 452
 453         SetAttrs(obj, MUIA_Dirlist_Status        , MUIV_Dirlist_Status_Invalid,
 454                 MUIA_Dirlist_NumBytes  , 0                            ,
 455                 MUIA_Dirlist_NumFiles  , 0                            ,
 456                 MUIA_Dirlist_NumDrawers, 0                            ,
 457                 TAG_DONE                                              );
 458     }
 459
 460     if (data->directory)
 461     {
 462         ReadDirectory(obj, data);
 463     }
 464     set(obj, MUIA_List_Quiet, FALSE);
 465
 466     return 0;
 467 }
 468
 469
 470 #if ZUNE_BUILTIN_DIRLIST
 471 BOOPSI_DISPATCHER(IPTR, Dirlist_Dispatcher, cl, obj, msg)
 472 {
 473     switch (msg->MethodID)
 474     {
 475         case OM_NEW:              return Dirlist__OM_NEW(cl, obj, (struct opSet *)msg);
 476         case OM_DISPOSE:          return Dirlist__OM_DISPOSE(cl, obj, msg);
 477         case OM_SET:              return Dirlist__OM_SET(cl, obj, (struct opSet *)msg);
 478         case OM_GET:              return Dirlist__OM_GET(cl, obj, (struct opGet *)msg);
 479         case MUIM_Dirlist_ReRead: return Dirlist__MUIM_Dirlist_ReRead(cl, obj, (struct opGet *)msg);
 480         default:                  return DoSuperMethodA(cl, obj, msg);
 481     }
 482 }
 483 BOOPSI_DISPATCHER_END
 484
 485 const struct __MUIBuiltinClass _MUI_Dirlist_desc =
 486 {
 487     MUIC_Dirlist,
 488     MUIC_List,
 489     sizeof(struct Dirlist_DATA),
 490     (void*)Dirlist_Dispatcher
 491 };
 492 #endif /* ZUNE_BUILTIN_DIRLIST */