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