workbench/libs/icon/identify.c

   1 /*
   2     Copyright © 2003-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #include <dos/dos.h>
   9 #include <dos/dosextens.h>
  10 #include <workbench/workbench.h>
  11 #include <workbench/icon.h>
  12 #include <datatypes/datatypes.h>
  13 #include <datatypes/datatypesclass.h>
  14 #include <utility/hooks.h>
  15
  16 #include <proto/exec.h>
  17 #include <proto/dos.h>
  18 #include <proto/icon.h>
  19 #include <proto/utility.h>
  20 #include <proto/datatypes.h>
  21
  22 #include "icon_intern.h"
  23
  24 #include <string.h>
  25
  26 #ifndef ID_FAT12_DISK
  27 #define ID_FAT12_DISK      AROS_MAKE_ID('F','A','T',0) /* FAT12 */
  28 #define ID_FAT16_DISK      AROS_MAKE_ID('F','A','T',1) /* FAT16 */
  29 #define ID_FAT32_DISK      AROS_MAKE_ID('F','A','T',2) /* FAT32 */
  30 #endif
  31 #ifndef ID_CDFS_DISK
  32 #define ID_CDFS_DISK       AROS_MAKE_ID('C','D','F','S') /* CDFS */
  33 #endif
  34
  35 /*** Prototypes *************************************************************/
  36 BOOL __FindDeviceName_WB(STRPTR buffer, LONG length, BPTR lock, APTR *theDOSBase);
  37 struct DiskObject *__GetDefaultIconFromName_WB(CONST_STRPTR name, const struct TagItem *tags, struct IconBase *IconBase);
  38 struct DiskObject *__GetDefaultIconFromType_WB(LONG type, const struct TagItem *tags, struct IconBase *IconBase);
  39 LONG __FindDiskType_WB(STRPTR volname, BPTR lock, struct IconBase *IconBase);
  40
  41 /*** Macros *****************************************************************/
  42 #define FindDeviceName(buffer, length, volume) (__FindDeviceName_WB((buffer), (length), (volume), DOSBase))
  43 #define GetDefaultIconFromName(name, tags) (__GetDefaultIconFromName_WB((name), (tags), IconBase))
  44 #define GetDefaultIconFromType(type, tags) (__GetDefaultIconFromType_WB((type), (tags), IconBase))
  45 #define FindDiskType(volname, lock) (__FindDiskType_WB((volname),(lock),IconBase))
  46 /*** Functions **************************************************************/
  47 LONG __FindType_WB(BPTR lock, struct IconBase *IconBase)
  48 {
  49     LONG                  type = -1;
  50     struct FileInfoBlock *fib  = AllocDosObject(DOS_FIB, TAG_DONE);
  51
  52     if (fib != NULL)
  53     {
  54         if (Examine(lock, fib))
  55         {
  56             D(bug("[%s] Examine says: fib_DirEntryType=%d\n", __func__, fib->fib_DirEntryType));
  57             D(bug("[%s] Examine says: fib_Protection=%x\n", __func__, fib->fib_Protection));
  58             /* Identify object ---------------------------------------------*/
  59             if (fib->fib_DirEntryType == ST_ROOT)
  60             {
  61                 /* It's a disk/volume/root ---------------------------------*/
  62                 type = WBDISK;
  63             }
  64             else if (fib->fib_DirEntryType > 0)
  65             {
  66                 /* It's a directory ----------------------------------------*/
  67                 type = WBDRAWER;
  68             }
  69             else
  70             {
  71                 /* It's a file ---------------------------------------------*/
  72                 if (DataTypesBase != NULL)
  73                 {
  74                     /* Use datatypes to identify the file ------------------*/
  75                     struct DataType *dt = ObtainDataType
  76                     (
  77                         DTST_FILE, (APTR)lock, TAG_DONE
  78                     );
  79
  80                     if (dt != NULL)
  81                     {
  82                         struct DataTypeHeader *dth = dt->dtn_Header;
  83
  84                         if
  85                         (
  86                                dth->dth_GroupID == GID_SYSTEM
  87                             && dth->dth_ID      == ID_EXECUTABLE
  88                         )
  89                         {
  90                             /* It's an executable file */
  91                             type = WBTOOL;
  92                         }
  93                         else
  94                         {
  95                             /* It's a project file of some kind */
  96                             type = WBPROJECT;
  97                         }
  98
  99                         ReleaseDataType(dt);
 100                     }
 101                 }
 102
 103                 if (type == -1)
 104                 {
 105                     /* Fallback to a more primitive identification ---------*/
 106                     if ((fib->fib_Protection & FIBF_EXECUTE) == 0)
 107                     {
 108                         type = WBTOOL;
 109                     }
 110                     else
 111                     {
 112                         type = WBPROJECT;
 113                     }
 114                 }
 115
 116             }
 117         }
 118
 119         FreeDosObject(DOS_FIB, fib);
 120     }
 121
 122     return type;
 123 }
 124
 125 struct DiskObject *__FindDefaultIcon_WB
 126 (
 127     struct IconIdentifyMsg *iim, struct IconBase *IconBase
 128 )
 129 {
 130     struct DiskObject *icon = NULL;
 131
 132     /* Identify object -----------------------------------------------------*/
 133     if (iim->iim_FIB->fib_DirEntryType == ST_ROOT)
 134     {
 135         /* It's a disk/volume/root -------------------------------------*/
 136         TEXT device[MAXFILENAMELENGTH];
 137
 138         if
 139         (
 140             FindDeviceName
 141             (
 142                 device, MAXFILENAMELENGTH,
 143                 iim->iim_FileLock
 144             )
 145         )
 146         {
 147             BPTR lock = Lock(device, SHARED_LOCK);
 148             LONG type = FindDiskType(iim->iim_FIB->fib_FileName, lock);
 149             UnLock(lock);
 150             if (strlen(device) <= 5)
 151             {
 152                 if (strcasecmp(device, "RAM:") == 0)
 153                 {
 154                     icon = GetDefaultIconFromName("RAM", iim->iim_Tags);
 155                 }
 156                 else if (strncasecmp(device, "RAD", 3) == 0)
 157                 {
 158                     icon = GetDefaultIconFromName("RAD", iim->iim_Tags);
 159                 }
 160                 else if (strncasecmp(device, "DF", 2) == 0)
 161                 {
 162                     icon = GetDefaultIconFromName("Floppy", iim->iim_Tags);
 163                 }
 164                 else if (strncasecmp(device, "CD", 2) == 0)
 165                 {
 166                     icon = GetDefaultIconFromName("CDROM", iim->iim_Tags);
 167                 }
 168                 else if
 169                 (
 170                        strncasecmp(device, "DH",  2) == 0
 171                     || strncasecmp(device, "HD",  2) == 0
 172                     || strncasecmp(device, "EMU", 3) == 0
 173                 )
 174                 {
 175                     icon = GetDefaultIconFromName("Harddisk", iim->iim_Tags);
 176                 }
 177                 else if (strcasecmp(device, "HOME") == 0)
 178                 {
 179                     icon = GetDefaultIconFromName("Home", iim->iim_Tags);
 180                 }
 181                 else if (type)
 182                 {
 183                     D(bug("[icon] Identify Type: 0x%8x\n",type));
 184                     switch(type)
 185                     {
 186                         case ID_MSDOS_DISK:
 187                         case ID_FAT12_DISK:
 188                         case ID_FAT16_DISK:
 189                         case ID_FAT32_DISK:
 190                             icon = GetDefaultIconFromName("FAT", iim->iim_Tags);
 191                             break;
 192                         case ID_SFS_BE_DISK:
 193                         case ID_SFS_LE_DISK:
 194                             icon = GetDefaultIconFromName("SFS", iim->iim_Tags);
 195                             break;
 196                         case ID_FFS_DISK:
 197                         case ID_INTER_DOS_DISK:
 198                         case ID_INTER_FFS_DISK:
 199                         case ID_FASTDIR_DOS_DISK:
 200                         case ID_FASTDIR_FFS_DISK:
 201                             icon = GetDefaultIconFromName("ADF", iim->iim_Tags);
 202                             break;
 203                         case ID_CDFS_DISK:
 204                             icon = GetDefaultIconFromName("CDROM", iim->iim_Tags);
 205                             break;
 206                         default:
 207                             icon = GetDefaultIconFromName("Disk", iim->iim_Tags);
 208                             break;
 209                     }
 210                 }
 211             }
 212             else if (strncasecmp(device, "USB", 3) ==0)
 213             {
 214                 icon = GetDefaultIconFromName("USB", iim->iim_Tags);
 215             }
 216             else
 217             {
 218                 /* Fall back to generic harddisk icon */
 219                 if (icon ==  NULL)
 220                 {
 221                     icon = GetDefaultIconFromName("Harddisk", iim->iim_Tags);
 222                 }
 223             }
 224         }
 225
 226         /* Fall back to generic disk icon */
 227         if (icon == NULL)
 228         {
 229             icon = GetDefaultIconFromType(WBDISK, iim->iim_Tags);
 230         }
 231
 232         if (icon != NULL)
 233         {
 234             /* Force the icon type */
 235             icon->do_Type = WBDISK;
 236         }
 237     }
 238     else if (iim->iim_FIB->fib_DirEntryType > 0)
 239     {
 240         /* It's a directory --------------------------------------------*/
 241         /* Check if it is a trashcan directory */
 242         if (iim->iim_ParentLock != BNULL)
 243         {
 244             /* Is iim_ParentLock a root? */
 245             BPTR root = ParentDir(iim->iim_ParentLock);
 246
 247             if (root == BNULL)
 248             {
 249                 /* Yes, it's a root. See if it contains our trashcan. */
 250                 BPTR cd   = CurrentDir(iim->iim_ParentLock);
 251
 252                 UBYTE buffer[MAXFILENAMELENGTH], buffer1[MAXFILENAMELENGTH];
 253
 254                 /* SFS .recycled Trashcan */
 255                 BPTR lock = Lock(".recycled", ACCESS_READ);
 256                 NameFromLock(iim->iim_FileLock, buffer, MAXFILENAMELENGTH);
 257
 258                 if (lock != BNULL)
 259                 {
 260                     NameFromLock(lock, buffer1, MAXFILENAMELENGTH);
 261                     if (strcasecmp(buffer, buffer1) == 0)
 262                     {
 263                         icon = GetDefaultIconFromType(WBGARBAGE, iim->iim_Tags);
 264                     }
 265                     UnLock(lock);
 266                 }
 267                 CurrentDir(cd);
 268             }
 269             else
 270             {
 271                 UnLock(root);
 272             }
 273         }
 274
 275         /* Fall back to generic drawer icon */
 276         if (icon == NULL)
 277         {
 278             icon = GetDefaultIconFromType(WBDRAWER, iim->iim_Tags);
 279         }
 280
 281         if (icon != NULL)
 282         {
 283             /* Force the icon type */
 284             icon->do_Type = WBDRAWER;
 285         }
 286     }
 287     else
 288     {
 289         /* It's a file -----------------------------------------------------*/
 290         if (DataTypesBase != NULL)
 291         {
 292             /* Use datatypes to identify the file --------------------------*/
 293             struct DataType *dt = ObtainDataType
 294             (
 295                 DTST_FILE, (APTR)iim->iim_FileLock, TAG_DONE
 296             );
 297
 298             if (dt != NULL)
 299             {
 300                 struct DataTypeHeader *dth = dt->dtn_Header;
 301
 302                 if
 303                 (
 304                        dth->dth_GroupID == GID_SYSTEM
 305                     && dth->dth_ID      == ID_EXECUTABLE
 306                 )
 307                 {
 308                     /* It's an executable file -----------------------------*/
 309                     icon = GetDefaultIconFromType(WBTOOL, iim->iim_Tags);
 310
 311                     if (icon != NULL)
 312                     {
 313                         /* Force the icon type */
 314                         icon->do_Type = WBTOOL;
 315                     }
 316                 }
 317                 else
 318                 {
 319                     /* It's a project file of some kind --------------------*/
 320                     icon = GetDefaultIconFromName(dth->dth_Name, iim->iim_Tags);
 321
 322                     /* Fall back to generic filetype group icon */
 323                     if (icon == NULL)
 324                     {
 325                         STRPTR name = NULL;
 326
 327                         switch (dth->dth_GroupID)
 328                         {
 329                             case GID_SYSTEM:     name = "System";     break;
 330                             case GID_TEXT:       name = "Text";       break;
 331                             case GID_DOCUMENT:   name = "Document";   break;
 332                             case GID_SOUND:      name = "Sound";      break;
 333                             case GID_INSTRUMENT: name = "Instrument"; break;
 334                             case GID_MUSIC:      name = "Music";      break;
 335                             case GID_PICTURE:    name = "Picture";    break;
 336                             case GID_ANIMATION:  name = "Animation";  break;
 337                             case GID_MOVIE:      name = "Movie";      break;
 338                         }
 339
 340                         if (name != NULL)
 341                         {
 342                             icon = GetDefaultIconFromName(name, iim->iim_Tags);
 343                         }
 344                     }
 345
 346                     /* Fall back to generic project icon */
 347                     if (icon == NULL)
 348                     {
 349                         icon = GetDefaultIconFromType(WBPROJECT, iim->iim_Tags);
 350                     }
 351
 352                     if (icon != NULL)
 353                     {
 354                         /* Force the icon type */
 355                         icon->do_Type = WBPROJECT;
 356                     }
 357                 }
 358
 359                 ReleaseDataType(dt);
 360             }
 361         }
 362
 363         if (icon == NULL)
 364         {
 365             /* Fallback to a more primitive identification -----------------*/
 366             if ((iim->iim_FIB->fib_Protection & FIBF_EXECUTE) == 0)
 367             {
 368                 /* It's an executable files --------------------------------*/
 369                 icon = GetDefaultIconFromType(WBTOOL, iim->iim_Tags);
 370
 371                 if (icon != NULL)
 372                 {
 373                     /* Force the icon type */
 374                     icon->do_Type = WBTOOL;
 375                 }
 376             }
 377             else
 378             {
 379                 /* It's a project file of some kind ------------------------*/
 380                 icon = GetDefaultIconFromType(WBPROJECT, iim->iim_Tags);
 381
 382                 if (icon != NULL)
 383                 {
 384                     /* Force the icon type */
 385                     icon->do_Type = WBPROJECT;
 386                 }
 387             }
 388         }
 389     }
 390
 391     return icon;
 392 }
 393
 394 /*** Support functions ******************************************************/
 395 LONG __FindDiskType_WB(STRPTR volname, BPTR lock, struct IconBase *IconBase)
 396 {
 397     LONG disktype = ID_NO_DISK_PRESENT;
 398     struct DosList *dl, *dn;
 399
 400     dl = LockDosList(LDF_VOLUMES|LDF_READ);
 401     if (dl)
 402     {
 403         dn = FindDosEntry(dl, volname, LDF_VOLUMES);
 404         if (dn)
 405         {
 406             disktype = dn->dol_misc.dol_volume.dol_DiskType;
 407         }
 408     UnLockDosList(LDF_VOLUMES|LDF_READ);
 409     }
 410
 411     if (disktype == 0) //FFS workaround (dol_DiskType == 0)
 412     {
 413         struct InfoData *id = AllocMem(sizeof(struct InfoData), MEMF_PUBLIC|MEMF_CLEAR);
 414         if (id != NULL)
 415         {
 416             if (Info(lock, id))
 417             {
 418                 disktype = id->id_DiskType;
 419             }
 420             FreeMem(id,sizeof(struct InfoData));
 421         }
 422     }
 423     return disktype;
 424 }
 425
 426 BOOL __FindDeviceName_WB
 427 (
 428     STRPTR device, LONG length, BPTR lock,
 429     APTR *theDOSBase
 430 )
 431 {
 432 #undef DOSBase
 433 #define DOSBase theDOSBase
 434     struct DosList *dl      = LockDosList(LDF_DEVICES | LDF_READ);
 435     BOOL            success = FALSE;
 436
 437     if (dl != NULL)
 438     {
 439         struct DosList *dol = dl;
 440         struct MsgPort *port = ((struct FileLock *) BADDR(lock))->fl_Task;
 441
 442         while ((dol = NextDosEntry(dol, LDF_DEVICES | LDF_READ)) != NULL)
 443         {
 444             STRPTR devname = AROS_BSTR_ADDR(dol->dol_Name);
 445             ULONG len = AROS_BSTR_strlen(dol->dol_Name);
 446
 447             if (dol->dol_Task == port) {
 448                 CopyMem(devname, device, len);
 449                 device[len++] = ':';
 450                 device[len] = 0;
 451
 452                 success = TRUE;
 453                 break;
 454             }
 455         }
 456
 457         UnLockDosList(LDF_DEVICES | LDF_READ);
 458     }
 459
 460     return success;
 461 }
 462
 463 struct DiskObject *__GetDefaultIconFromName_WB
 464 (
 465     CONST_STRPTR name, const struct TagItem *tags, struct IconBase *IconBase
 466 )
 467 {
 468     return GetIconTags
 469     (
 470         NULL,
 471         ICONGETA_GetDefaultName, (IPTR)name,
 472         TAG_END
 473     );
 474 }
 475
 476 struct DiskObject *__GetDefaultIconFromType_WB
 477 (
 478     LONG type, const struct TagItem *tags, struct IconBase *IconBase
 479 )
 480 {
 481     return GetIconTags
 482     (
 483         NULL,
 484         ICONGETA_GetDefaultType, type,
 485         TAG_END
 486     );
 487 }