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