workbench/libs/icon/support.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Miscellaneous support functions.
   6 */
   7
   8 #include <string.h>
   9 #include <stdio.h>
  10
  11 #include "icon_intern.h"
  12 #include "support.h"
  13
  14 #define DEBUG 1
  15 #   include <aros/debug.h>
  16
  17 extern const IPTR IconDesc[];
  18
  19 BPTR __OpenIcon_WB(CONST_STRPTR name, LONG mode, struct IconBase *IconBase)
  20 {
  21     BPTR  file       = NULL;
  22     ULONG nameLength = strlen(name);
  23
  24     if (name[nameLength - 1] == ':')
  25     {
  26         BPTR lock = Lock(name, ACCESS_READ);
  27
  28         if (lock != NULL)
  29         {
  30             BPTR cd = CurrentDir(lock);
  31
  32             file = Open("Disk.info", mode);
  33
  34             CurrentDir(cd);
  35             UnLock(lock);
  36         }
  37     }
  38     else
  39     {
  40         ULONG  length = nameLength + 5 /* strlen(".info") */ + 1 /* '\0' */;
  41         STRPTR path   = AllocVecPooled(POOL, length);
  42
  43         if(path != NULL)
  44         {
  45             strlcpy(path, name, length);
  46             strlcat(path, ".info", length);
  47
  48             file = Open(path, mode);
  49
  50             FreeVecPooled(POOL, path);
  51         }
  52         else
  53         {
  54             SetIoErr(ERROR_NO_FREE_STORE);
  55             return NULL;
  56         }
  57     }
  58
  59     return file;
  60 }
  61
  62 BOOL __CloseIcon_WB(BPTR file, struct IconBase *IconBase)
  63 {
  64     return Close(file);
  65 }
  66
  67 BPTR __OpenDefaultIcon_WB(CONST_STRPTR name, LONG mode, struct IconBase *IconBase)
  68 {
  69     static const char * const  readPaths[]  = { "ENV:SYS", "ENVARC:SYS", NULL };
  70     static const char * const  writePaths[] = { "ENV:SYS", NULL };
  71     const char * const        *paths        = NULL;
  72     CONST_STRPTR               path         = NULL;
  73     BPTR                       file         = NULL;
  74     UBYTE                      i;
  75
  76     /* Make sure it's a plain filename; paths are not allowed */
  77     if (strpbrk(name, "/:") != NULL) return NULL;
  78
  79     if (mode == MODE_OLDFILE) paths = readPaths;
  80     else                      paths = writePaths;
  81
  82     /* Attempt to open the icon from each path in turn */
  83     for (i = 0, path = paths[0]; path != NULL; i++, path = paths[i])
  84     {
  85         TEXT  buffer[256]; /* Filename buffer; should be more than large enough */
  86         ULONG copied;      /* Number of bytes copied */
  87
  88         copied = snprintf(buffer, sizeof(buffer), "%s/def_%s.info", path, name);
  89
  90         if (copied < sizeof(buffer)) /* check for truncation */
  91         {
  92             if ((file = Open(buffer, mode)) != NULL)
  93             {
  94                 break;
  95             }
  96         }
  97     }
  98
  99     return file;
 100 }
 101
 102 BOOL __CloseDefaultIcon_WB(BPTR file, struct IconBase *IconBase)
 103 {
 104     return Close(file);
 105 }
 106
 107 struct DiskObject *__ReadIcon_WB(BPTR file, struct IconBase *IconBase)
 108 {
 109     struct DiskObject *temp = NULL, /* Temporary icon data */
 110                       *icon = NULL; /* Final icon data */
 111
 112     if (ReadStruct(&(LB(IconBase)->dsh), (APTR *) &temp, file, IconDesc))
 113     {
 114         // FIXME: consistency checks! (ie that WBDISK IS for a disk, WBDRAWER for a dir, WBTOOL for an executable)
 115         /*
 116             Duplicate the disk object so it can be freed with
 117             FreeDiskObject().
 118         */
 119         // FIXME: is there any way to avoid this?
 120         icon = DupDiskObject
 121         (
 122             temp,
 123             ICONDUPA_JustLoadedFromDisk, TRUE,
 124             TAG_DONE
 125         );
 126     }
 127
 128     // FIXME: Read/FreeStruct seem a bit broken in memory handling
 129     // FIXME: shouldn't ReadStruct deallocate memory if it fails?!?!
 130     if (temp != NULL) FreeStruct(temp, IconDesc);
 131
 132     if (!icon)
 133     {
 134         if (!PNGBase) PNGBase = OpenLibrary("datatypes/png.datatype", 0);
 135
 136         if (PNGBase && ReadIconPNG(&temp, file, IconBase))
 137         {
 138             /*
 139                 Duplicate the disk object so it can be freed with
 140                 FreeDiskObject().
 141             */
 142             // FIXME: is there any way to avoid this?
 143             icon = DupDiskObject
 144             (
 145                 temp,
 146                 ICONDUPA_JustLoadedFromDisk, TRUE,
 147                 TAG_DONE
 148             );
 149
 150             FreeIconPNG(temp, IconBase);
 151         }
 152
 153     }
 154
 155     return icon;
 156 }
 157
 158 BOOL __WriteIcon_WB(BPTR file, struct DiskObject *icon, struct IconBase *IconBase)
 159 {
 160     struct NativeIcon *nativeicon = GetNativeIcon(icon, IconBase);
 161
 162     if (nativeicon && nativeicon->iconPNG.handle)
 163     {
 164         return WriteIconPNG(file, icon, IconBase);
 165     }
 166     else
 167     {
 168         return WriteStruct(&(LB(IconBase)->dsh), (APTR) icon, file, IconDesc);
 169     }
 170 }
 171
 172 BPTR __LockObject_WB(CONST_STRPTR name, LONG mode, struct Library *IconBase)
 173 {
 174     BPTR lock = Lock(name, mode);
 175
 176     if (lock == NULL && strcasecmp(name + strlen(name) - 5, ":Disk") == 0)
 177     {
 178         // FIXME: perhaps allocate buffer from heap?
 179         TEXT  buffer[256];               /* Path buffer */
 180         ULONG length = strlen(name) - 3; /* Amount to copy + NULL */
 181
 182         if (sizeof(buffer) >= length)
 183         {
 184             strlcpy(buffer, name, length);
 185             lock = Lock(buffer, mode);
 186         }
 187     }
 188
 189     return lock;
 190 }
 191
 192 VOID __UnLockObject_WB(BPTR lock, struct Library *IconBase)
 193 {
 194     if (lock != NULL) UnLock(lock);
 195 }
 196
 197
 198 CONST_STRPTR GetDefaultIconName(LONG type)
 199 {
 200     static const char * const defaultNames[] =
 201     {
 202         "Disk",         /* WBDISK    (1) */
 203         "Drawer",       /* WBDRAWER  (2) */
 204         "Tool",         /* WBTOOL    (3) */
 205         "Project",      /* WBPROJECT (4) */
 206         "Trashcan",     /* WBGARBAGE (5) */
 207         "Device",       /* WBDEVICE  (6) */
 208         "Kick",         /* WBKICK    (7) */
 209         "AppIcon"       /* WBAPPICON (8) */
 210     };
 211
 212     if (type >= 1 && type <= 8)
 213     {
 214         return defaultNames[type - 1];
 215     }
 216     else
 217     {
 218         return NULL;
 219     }
 220 }
 221
 222
 223 LONG CalcIconHash(struct DiskObject *dobj)
 224 {
 225     LONG l1, l2, l3, l4, hash;
 226
 227     /* FIXME: Probably sucks. I have no clue about this hash stuff */
 228
 229     l1 = ((LONG)dobj) & 0xFF;
 230     l2 = (((LONG)dobj) >> 8) & 0xFF;
 231     l3 = (((LONG)dobj) >> 16) & 0xFF;
 232     l4 = (((LONG)dobj) >> 24) & 0xFF;
 233
 234     hash = (l1 + l2 + l3 + l4) % ICONLIST_HASHSIZE;
 235
 236     return hash;
 237 }
 238
 239 VOID AddIconToList(struct NativeIcon *icon, struct IconBase *IconBase)
 240 {
 241     LONG hash;
 242
 243     hash = CalcIconHash(&icon->dobj);
 244
 245     ObtainSemaphore(&IconBase->iconlistlock);
 246     AddTail((struct List *)&IconBase->iconlists[hash], (struct Node *)&icon->node);
 247     ReleaseSemaphore(&IconBase->iconlistlock);
 248 }
 249
 250 VOID RemoveIconFromList(struct NativeIcon *icon, struct IconBase *IconBase)
 251 {
 252     ObtainSemaphore(&IconBase->iconlistlock);
 253     Remove((struct Node *)&icon->node);
 254     ReleaseSemaphore(&IconBase->iconlistlock);
 255 }
 256
 257 struct NativeIcon *GetNativeIcon(struct DiskObject *dobj, struct IconBase *IconBase)
 258 {
 259     struct NativeIcon *icon, *reticon = NULL;
 260     LONG               hash;
 261     LONG i = 0;
 262
 263     hash = CalcIconHash(dobj);
 264
 265     ObtainSemaphoreShared(&IconBase->iconlistlock);
 266     ForeachNode((struct List *)&IconBase->iconlists[hash], icon)
 267     {
 268         i++;
 269         if (dobj == &icon->dobj)
 270         {
 271             reticon = icon;
 272             break;
 273         }
 274     }
 275     ReleaseSemaphore(&IconBase->iconlistlock);
 276
 277     return reticon;
 278 }