workbench/libs/icon/identify.c

   1 /*
   2     Copyright © 2003-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #define DEBUG 0
   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 <string.h>
  23
  24
  25 /*** Prototypes *************************************************************/
  26 BOOL __FindDeviceName_WB(STRPTR buffer, LONG length, CONST_STRPTR volume, struct DosLibrary *DOSBase);
  27 struct DiskObject *__GetDefaultIconFromName_WB(CONST_STRPTR name, const struct TagItem *tags, struct Library *IconBase);
  28 struct DiskObject *__GetDefaultIconFromType_WB(LONG type, const struct TagItem *tags, struct Library *IconBase);
  29
  30 /*** Macros *****************************************************************/
  31 #define FindDeviceName(buffer, length, volume) (__FindDeviceName_WB((buffer), (length), (volume), DOSBase))
  32 #define GetDefaultIconFromName(name, tags) (__GetDefaultIconFromName_WB((name), (tags), IconBase))
  33 #define GetDefaultIconFromType(type, tags) (__GetDefaultIconFromType_WB((type), (tags), IconBase))
  34
  35 /*** Functions **************************************************************/
  36 LONG __FindType_WB(BPTR lock, struct Library *IconBase)
  37 {
  38     LONG                  type = -1;
  39     struct FileInfoBlock *fib  = AllocDosObject(DOS_FIB, TAG_DONE);
  40
  41     if (fib != NULL)
  42     {
  43         if (Examine(lock, fib))
  44         {
  45             /* Identify object ---------------------------------------------*/
  46             if (fib->fib_DirEntryType == ST_ROOT)
  47             {
  48                 /* It's a disk/volume/root ---------------------------------*/
  49                 type = WBDISK;
  50             }
  51             else if (fib->fib_DirEntryType > 0)
  52             {
  53                 /* It's a directory ----------------------------------------*/
  54                 type = WBDRAWER;
  55             }
  56             else
  57             {
  58                 /* It's a file ---------------------------------------------*/
  59                 if (DataTypesBase != NULL)
  60                 {
  61                     /* Use datatypes to identify the file ------------------*/
  62                     struct DataType *dt = ObtainDataType
  63                     (
  64                         DTST_FILE, lock, TAG_DONE
  65                     );
  66
  67                     if (dt != NULL)
  68                     {
  69                         struct DataTypeHeader *dth = dt->dtn_Header;
  70
  71                         if
  72                         (
  73                                dth->dth_GroupID == GID_SYSTEM
  74                             && dth->dth_ID      == ID_EXECUTABLE
  75                         )
  76                         {
  77                             /* It's a executable file */
  78                             type = WBTOOL;
  79                         }
  80                         else
  81                         {
  82                             /* It's a project file of some kind */
  83                             type = WBPROJECT;
  84                         }
  85
  86                         ReleaseDataType(dt);
  87                     }
  88                 }
  89
  90                 if (type == -1)
  91                 {
  92                     /* Fallback to a more primitive identification ---------*/
  93                     if ((fib->fib_Protection & FIBF_EXECUTE) == 0)
  94                     {
  95                         type = WBTOOL;
  96                     }
  97                     else
  98                     {
  99                         type = WBPROJECT;
 100                     }
 101                 }
 102
 103             }
 104         }
 105
 106         FreeDosObject(DOS_FIB, fib);
 107     }
 108
 109     return type;
 110 }
 111
 112 struct DiskObject *__FindDefaultIcon_WB
 113 (
 114     struct IconIdentifyMsg *iim, struct Library *IconBase
 115 )
 116 {
 117     struct DiskObject *icon = NULL;
 118
 119     /* Identify object -----------------------------------------------------*/
 120     if (iim->iim_FIB->fib_DirEntryType == ST_ROOT)
 121     {
 122         /* It's a disk/volume/root -------------------------------------*/
 123         TEXT device[MAXFILENAMELENGTH];
 124
 125         if
 126         (
 127             FindDeviceName
 128             (
 129                 device, MAXFILENAMELENGTH,
 130                 iim->iim_FIB->fib_FileName
 131             )
 132         )
 133         {
 134             if (strlen(device) <= 5)
 135             {
 136                 if (strcasecmp(device, "RAM:") == 0)
 137                 {
 138                     icon = GetDefaultIconFromName("RAM", iim->iim_Tags);
 139                 }
 140                 else if (strncasecmp(device, "RAD", 3) == 0)
 141                 {
 142                     icon = GetDefaultIconFromName("RAD", iim->iim_Tags);
 143                 }
 144                 else if (strncasecmp(device, "DF", 2) == 0)
 145                 {
 146                     icon = GetDefaultIconFromName("Floppy", iim->iim_Tags);
 147                 }
 148                 else if (strncasecmp(device, "CD", 2) == 0)
 149                 {
 150                     icon = GetDefaultIconFromName("CDROM", iim->iim_Tags);
 151                 }
 152                 else if
 153                 (
 154                        strncasecmp(device, "DH",  2) == 0
 155                     || strncasecmp(device, "HD",  2) == 0
 156                     || strncasecmp(device, "EMU", 3) == 0
 157                 )
 158                 {
 159                     icon = GetDefaultIconFromName("Harddisk", iim->iim_Tags);
 160                 }
 161                 else if (strcasecmp(device, "HOME:") == 0)
 162                 {
 163                     icon = GetDefaultIconFromName("Home", iim->iim_Tags);
 164                 }
 165             }
 166             else
 167             {
 168                 /* Fall back to generic harddisk icon */
 169                 if (icon ==  NULL)
 170                 {
 171                     icon = GetDefaultIconFromName("Harddisk", iim->iim_Tags);
 172                 }
 173             }
 174         }
 175
 176         /* Fall back to generic disk icon */
 177         if (icon == NULL)
 178         {
 179             icon = GetDefaultIconFromType(WBDISK, iim->iim_Tags);
 180         }
 181
 182         if (icon != NULL)
 183         {
 184             /* Force the icon type */
 185             icon->do_Type = WBDISK;
 186         }
 187     }
 188     else if (iim->iim_FIB->fib_DirEntryType > 0)
 189     {
 190         /* It's a directory --------------------------------------------*/
 191         /* Check if it is a trashcan directory */
 192         if (iim->iim_ParentLock != NULL)
 193         {
 194             /* Is iim_ParentLock a root? */
 195             BPTR root = ParentDir(iim->iim_ParentLock);
 196
 197             if (root == NULL)
 198             {
 199                 /* Yes, it's a root. See if it contains our trashcan. */
 200                 BPTR cd   = CurrentDir(iim->iim_ParentLock);
 201
 202                 UBYTE buffer[MAXFILENAMELENGTH], buffer1[MAXFILENAMELENGTH];
 203
 204                 /* SFS .recycled Trashcan */
 205                 BPTR lock = Lock(".recycled", ACCESS_READ);
 206                 NameFromLock(iim->iim_FileLock, buffer, MAXFILENAMELENGTH);
 207
 208                 if (lock != NULL)
 209                 {
 210                     NameFromLock(lock, buffer1, MAXFILENAMELENGTH);
 211                     if (strcasecmp(buffer, buffer1) == 0)
 212                     {
 213                         icon = GetDefaultIconFromType(WBGARBAGE, iim->iim_Tags);
 214                     }
 215                     UnLock(lock);
 216                 }
 217                 CurrentDir(cd);
 218             }
 219             else
 220             {
 221                 UnLock(root);
 222             }
 223         }
 224
 225         /* Fall back to generic drawer icon */
 226         if (icon == NULL)
 227         {
 228             icon = GetDefaultIconFromType(WBDRAWER, iim->iim_Tags);
 229         }
 230
 231         if (icon != NULL)
 232         {
 233             /* Force the icon type */
 234             icon->do_Type = WBDRAWER;
 235         }
 236     }
 237     else
 238     {
 239         /* It's a file -----------------------------------------------------*/
 240         if (DataTypesBase != NULL)
 241         {
 242             /* Use datatypes to identify the file --------------------------*/
 243             struct DataType *dt = ObtainDataType
 244             (
 245                 DTST_FILE, iim->iim_FileLock, TAG_DONE
 246             );
 247
 248             if (dt != NULL)
 249             {
 250                 struct DataTypeHeader *dth = dt->dtn_Header;
 251
 252                 if
 253                 (
 254                        dth->dth_GroupID == GID_SYSTEM
 255                     && dth->dth_ID      == ID_EXECUTABLE
 256                 )
 257                 {
 258                     /* It's a executable file ------------------------------*/
 259                     icon = GetDefaultIconFromType(WBTOOL, iim->iim_Tags);
 260
 261                     if (icon != NULL)
 262                     {
 263                         /* Force the icon type */
 264                         icon->do_Type = WBTOOL;
 265                     }
 266                 }
 267                 else
 268                 {
 269                     /* It's a project file of some kind --------------------*/
 270                     icon = GetDefaultIconFromName(dth->dth_Name, iim->iim_Tags);
 271
 272                     /* Fall back to generic filetype group icon */
 273                     if (icon == NULL)
 274                     {
 275                         STRPTR name = NULL;
 276
 277                         switch (dth->dth_GroupID)
 278                         {
 279                             case GID_SYSTEM:     name = "System";     break;
 280                             case GID_TEXT:       name = "Text";       break;
 281                             case GID_DOCUMENT:   name = "Document";   break;
 282                             case GID_SOUND:      name = "Sound";      break;
 283                             case GID_INSTRUMENT: name = "Instrument"; break;
 284                             case GID_MUSIC:      name = "Music";      break;
 285                             case GID_PICTURE:    name = "Picture";    break;
 286                             case GID_ANIMATION:  name = "Animation";  break;
 287                             case GID_MOVIE:      name = "Movie";      break;
 288                         }
 289
 290                         if (name != NULL)
 291                         {
 292                             icon = GetDefaultIconFromName(name, iim->iim_Tags);
 293                         }
 294                     }
 295
 296                     /* Fall back to generic project icon */
 297                     if (icon == NULL)
 298                     {
 299                         icon = GetDefaultIconFromType(WBPROJECT, iim->iim_Tags);
 300                     }
 301
 302                     if (icon != NULL)
 303                     {
 304                         /* Force the icon type */
 305                         icon->do_Type = WBPROJECT;
 306                     }
 307                 }
 308
 309                 ReleaseDataType(dt);
 310             }
 311         }
 312
 313         if (icon == NULL)
 314         {
 315             /* Fallback to a more primitive identification -----------------*/
 316             if ((iim->iim_FIB->fib_Protection & FIBF_EXECUTE) == 0)
 317             {
 318                 /* It's an executable files --------------------------------*/
 319                 icon = GetDefaultIconFromType(WBTOOL, iim->iim_Tags);
 320
 321                 if (icon != NULL)
 322                 {
 323                     /* Force the icon type */
 324                     icon->do_Type = WBTOOL;
 325                 }
 326             }
 327             else
 328             {
 329                 /* It's a project file of some kind ------------------------*/
 330                 icon = GetDefaultIconFromType(WBPROJECT, iim->iim_Tags);
 331
 332                 if (icon != NULL)
 333                 {
 334                     /* Force the icon type */
 335                     icon->do_Type = WBPROJECT;
 336                 }
 337             }
 338         }
 339     }
 340
 341     return icon;
 342 }
 343
 344 /*** Support functions ******************************************************/
 345 BOOL __FindDeviceName_WB
 346 (
 347     STRPTR buffer, LONG length, CONST_STRPTR volume,
 348     struct DosLibrary *DOSBase
 349 )
 350 {
 351     struct DosList *dl      = LockDosList(LDF_DEVICES | LDF_READ);
 352     BOOL            success = FALSE;
 353
 354     if (dl != NULL)
 355     {
 356         struct DosList *dol = dl;
 357
 358         while ((dol = NextDosEntry(dol, LDF_DEVICES | LDF_READ)) != NULL)
 359         {
 360             TEXT device[MAXFILENAMELENGTH];
 361
 362             strlcpy(device, dol->dol_Ext.dol_AROS.dol_DevName, MAXFILENAMELENGTH);
 363
 364             if (strlcat(device, ":", MAXFILENAMELENGTH) < MAXFILENAMELENGTH)
 365             {
 366                 BPTR lock;
 367
 368                 if
 369                 (
 370                        IsFileSystem(device)
 371                     && (lock = Lock(device, ACCESS_READ)) != NULL
 372                 )
 373                 {
 374                     if (NameFromLock(lock, buffer, length))
 375                     {
 376                         buffer[strlen(buffer) - 1] = '\0'; /* Remove trailing ':' */
 377                         if (strcasecmp(volume, buffer) == 0)
 378                         {
 379                             if (strlcpy(buffer, device, length) < length)
 380                             {
 381                                 success = TRUE;
 382                             }
 383                             UnLock(lock);
 384                             break;
 385                         }
 386                     }
 387
 388                     UnLock(lock);
 389                 }
 390             }
 391         }
 392
 393         UnLockDosList(LDF_DEVICES | LDF_READ);
 394     }
 395
 396     return success;
 397 }
 398
 399 struct DiskObject *__GetDefaultIconFromName_WB
 400 (
 401     CONST_STRPTR name, const struct TagItem *tags, struct Library *IconBase
 402 )
 403 {
 404     return GetIconTags
 405     (
 406         NULL,
 407         ICONGETA_GetDefaultName, (IPTR) name,
 408         TAG_MORE,                (IPTR) tags
 409     );
 410 }
 411
 412 struct DiskObject *__GetDefaultIconFromType_WB
 413 (
 414     LONG type, const struct TagItem *tags, struct Library *IconBase
 415 )
 416 {
 417     return GetIconTags
 418     (
 419         NULL,
 420         ICONGETA_GetDefaultType,        type,
 421         TAG_MORE,                (IPTR) tags
 422     );
 423 }