workbench/libs/icon/support.c

   1 /*
   2     Copyright © 1995-2011, 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 #include <aros/debug.h>
  15
  16 extern const IPTR IconDesc[];
  17
  18 BPTR __OpenIcon_WB(CONST_STRPTR name, LONG mode, struct IconBase *IconBase)
  19 {
  20     BPTR  file       = BNULL;
  21     ULONG nameLength = strlen(name);
  22
  23     if (name[nameLength - 1] == ':')
  24     {
  25         BPTR lock = Lock(name, ACCESS_READ);
  26
  27         if (lock != BNULL)
  28         {
  29             BPTR cd = CurrentDir(lock);
  30
  31             file = Open("Disk.info", mode);
  32
  33             CurrentDir(cd);
  34             UnLock(lock);
  35         }
  36     }
  37     else
  38     {
  39         ULONG  length = nameLength + 5 /* strlen(".info") */ + 1 /* '\0' */;
  40         STRPTR path   = AllocVec(length, MEMF_PUBLIC);
  41
  42         if(path != NULL)
  43         {
  44             strlcpy(path, name, length);
  45             strlcat(path, ".info", length);
  46
  47             file = Open(path, mode);
  48
  49             FreeVec(path);
  50         }
  51         else
  52         {
  53             SetIoErr(ERROR_NO_FREE_STORE);
  54             return BNULL;
  55         }
  56     }
  57
  58     return file;
  59 }
  60
  61 BOOL __CloseIcon_WB(BPTR file, struct IconBase *IconBase)
  62 {
  63     return Close(file);
  64 }
  65
  66 BPTR __OpenDefaultIcon_WB(CONST_STRPTR name, LONG mode, struct IconBase *IconBase)
  67 {
  68     static const char * const  readPaths[]  = { "ENV:SYS", "ENVARC:SYS", NULL };
  69     static const char * const  writePaths[] = { "ENV:SYS", NULL };
  70     const char * const        *paths        = NULL;
  71     CONST_STRPTR               path         = NULL;
  72     BPTR                       file         = BNULL;
  73     UBYTE                      i;
  74
  75     /* Make sure it's a plain filename; paths are not allowed */
  76     if (strpbrk(name, "/:") != NULL) return BNULL;
  77
  78     if (mode == MODE_OLDFILE) paths = readPaths;
  79     else                      paths = writePaths;
  80
  81     /* Attempt to open the icon from each path in turn */
  82     for (i = 0, path = paths[0]; path != NULL; i++, path = paths[i])
  83     {
  84         TEXT  buffer[256]; /* Filename buffer; should be more than large enough */
  85         ULONG copied;      /* Number of bytes copied */
  86
  87         copied = snprintf(buffer, sizeof(buffer), "%s/def_%s.info", path, name);
  88
  89         if (copied < sizeof(buffer)) /* check for truncation */
  90         {
  91             if ((file = Open(buffer, mode)) != BNULL)
  92             {
  93                 break;
  94             }
  95         }
  96     }
  97
  98     return file;
  99 }
 100
 101 BOOL __CloseDefaultIcon_WB(BPTR file, struct IconBase *IconBase)
 102 {
 103     return Close(file);
 104 }
 105
 106 static const struct ColorRegister ehb_palette[] =
 107 {
 108     { 0x00, 0x00, 0x00 },
 109     { 0x00, 0x00, 0x7f },
 110     { 0x00, 0x7f, 0x00 },
 111     { 0x00, 0x7f, 0x7f },
 112     { 0x7f, 0x00, 0x00 },
 113     { 0x7f, 0x00, 0x7f },
 114     { 0x7f, 0x7f, 0x00 },
 115     { 0x7f, 0x7f, 0x7f },
 116     { 0xb0, 0xb0, 0xb0 },
 117     { 0x00, 0x00, 0xf0 },
 118     { 0x00, 0xf0, 0x00 },
 119     { 0x00, 0xf0, 0xf0 },
 120     { 0xf0, 0x00, 0x00 },
 121     { 0xf0, 0x00, 0xf0 },
 122     { 0xf0, 0xf0, 0x00 },
 123     { 0xf0, 0xf0, 0xf0 },
 124     { 0x00, 0x00, 0x00 },       /* 'Transparent' */
 125 };
 126
 127 VOID __FetchIconARGB_WB(struct DiskObject *icon, int id, struct IconBase *IconBase)
 128 {
 129     struct NativeIcon *ni = NATIVEICON(icon);
 130     struct NativeIconImage *image;
 131
 132     image = &ni->ni_Image[id];
 133
 134     if (image->ARGB)
 135         return;
 136
 137     if (ni->ni_Extra.Data != NULL && ni->ni_Extra.PNG[id].Offset >= 0) {
 138         image->ARGB = ReadMemPNG(icon, ni->ni_Extra.Data + ni->ni_Extra.PNG[id].Offset,
 139                                      &ni->ni_Face.Width, &ni->ni_Face.Height,
 140                                      NULL, NULL, IconBase);
 141     }
 142
 143     /* Prepare ARGB selected imagery, if needed */
 144     if (image->ARGB == NULL && ni->ni_Image[0].ARGB != NULL) {
 145         /* Synthesize a selected ARGB icon */
 146         ULONG area = ni->ni_Face.Width * ni->ni_Face.Height;
 147         image->ARGB = AllocMemIcon(icon, area * sizeof(UBYTE) * 4, MEMF_PUBLIC);
 148         if (image->ARGB) {
 149             CopyMem(ni->ni_Image[0].ARGB, (APTR)image->ARGB, area * sizeof(UBYTE) * 4);
 150             UBYTE *cp;
 151             for (cp = (APTR)image->ARGB; area > 0; area--, cp += 4) {
 152                 struct ColorRegister *cr = (APTR)&cp[1];
 153                 ChangeToSelectedIconColor(cr);
 154             }
 155         }
 156     }
 157
 158     return;
 159 }
 160
 161 /* If we have ARGB imagery, but no Palettized imagery,
 162  * synthesize some. Use an EHB palette, similar to the
 163  * VGA-16 color palette.
 164  *
 165  * The goal here is to be fast & usable, not slow and accurate.
 166  */
 167 VOID __FetchIconImage_WB(struct DiskObject *icon, int id, struct IconBase *IconBase)
 168 {
 169     struct NativeIcon *ni = NATIVEICON(icon);
 170     struct NativeIconImage *image;
 171     UBYTE *pixel, *idata;
 172     ULONG count;
 173
 174     image = &ni->ni_Image[id];
 175
 176     if (image->ImageData)
 177         return;
 178
 179     FetchIconARGB(icon, id);
 180
 181     /* If no ARGB, and we're the selected image... */
 182     if (!image->ARGB) {
 183         if (id == 1 &&
 184             image->Palette == NULL &&
 185             image->ImageData == NULL &&
 186             ni->ni_Image[0].Palette != NULL &&
 187             ni->ni_Image[0].ImageData != NULL) {
 188
 189             ULONG pens = ni->ni_Image[0].Pens;
 190             struct ColorRegister *newpal;
 191
 192             newpal = AllocMemIcon(icon, sizeof(struct ColorRegister)*pens, MEMF_PUBLIC);
 193             if (newpal) {
 194                 ULONG i;
 195
 196                 image->Pens = pens;
 197                 image->TransparentColor = ni->ni_Image[0].TransparentColor;
 198                 image->ImageData = ni->ni_Image[0].ImageData;
 199                 CopyMem(ni->ni_Image[0].Palette, newpal, sizeof(struct ColorRegister)*image->Pens);
 200                 for (i = 0; i < image->Pens; i++) {
 201                     if (i == image->TransparentColor)
 202                         continue;
 203                     ChangeToSelectedIconColor(&newpal[i]);
 204                 }
 205                 image->Palette = newpal;
 206             }
 207         }
 208     } else if (image->ARGB) {
 209         image->ImageData = AllocMemIcon(icon, ni->ni_Face.Width * ni->ni_Face.Height, MEMF_PUBLIC);
 210         image->Pens = 17;
 211         image->Palette = ehb_palette;
 212         image->TransparentColor = 17;
 213         pixel = (UBYTE *)image->ARGB;
 214         idata = (UBYTE *)image->ImageData;
 215         for (count = 0; count < ni->ni_Face.Width * ni->ni_Face.Height; count++, pixel+=4, idata++) {
 216             if (pixel[0] == 0) {
 217                 *idata = image->TransparentColor;
 218             } else {
 219                 UBYTE i,r,g,b;
 220
 221                 r = pixel[1];
 222                 g = pixel[2];
 223                 b = pixel[3];
 224
 225                 /* Determine max intensity */
 226                 i = (r > g) ? r : g;
 227                 i = (i > b) ? i : b;
 228
 229                 /* Rescale by the intensity */
 230                 if (i == 0) {
 231                     *idata = 0;
 232                 } else {
 233                     r = (r > (i/4*3)) ? 1 : 0;
 234                     g = (g > (i/4*3)) ? 1 : 0;
 235                     b = (b > (i/4*3)) ? 1 : 0;
 236                     i = (i > 0xd0) ? 1 : 0;
 237
 238                     *idata = (i << 3) | (r << 2) | (g << 1) | (b << 0);
 239                 }
 240             }
 241         }
 242     }
 243 }
 244
 245
 246 /* Any last-minute changes to the Icon go here before it
 247  * is returned.
 248  */
 249 VOID __PrepareIcon_WB(struct DiskObject *icon, struct IconBase *IconBase)
 250 {
 251     /* Ensure that do_DrawerData exists for WBDISK and WBDRAWER objects */
 252     if ((icon->do_Type == WBDISK || icon->do_Type == WBDRAWER) &&
 253         icon->do_DrawerData == NULL) {
 254         icon->do_DrawerData = AllocMemIcon(icon, sizeof(struct DrawerData), MEMF_PUBLIC | MEMF_CLEAR);
 255         icon->do_DrawerData->dd_NewWindow.LeftEdge = 50;
 256         icon->do_DrawerData->dd_NewWindow.TopEdge = 50;
 257         icon->do_DrawerData->dd_NewWindow.Width = 400;
 258         icon->do_DrawerData->dd_NewWindow.Height = 150;
 259     }
 260
 261     /* Clean out dangling pointers that should no long be
 262      * present
 263      */
 264     if (icon->do_DrawerData) {
 265         icon->do_DrawerData->dd_NewWindow.FirstGadget = NULL;
 266         icon->do_DrawerData->dd_NewWindow.Screen = NULL;
 267         icon->do_DrawerData->dd_NewWindow.BitMap = NULL;
 268     }
 269
 270     return;
 271 }
 272
 273
 274
 275 struct DiskObject *__ReadIcon_WB(BPTR file, struct IconBase *IconBase)
 276 {
 277     struct DiskObject *icon;
 278
 279     icon = NewDiskObject(0);
 280     if (icon == NULL)
 281         return NULL;
 282
 283     Seek(file, 0, OFFSET_BEGINNING);
 284     if (ReadStruct(&(LB(IconBase)->dsh), (APTR *) &icon, (APTR)file, IconDesc))
 285     {
 286         D(bug("[ReadIcon] Return classic icon %p\n", icon));
 287         return icon;
 288     }
 289     FreeDiskObject(icon);
 290
 291     if (CyberGfxBase) {
 292         /* PNG icons don't have any fallback renders, so if we
 293          * don't have CyberGfxBase, we couldn't draw them on-screen
 294          * anyway.
 295          */
 296         icon = NewDiskObject(0);
 297         if (icon == NULL)
 298             return NULL;
 299
 300         if (ReadIconPNG(icon, file, IconBase))
 301         {
 302             D(bug("[ReadIcon] Return PNG icon %p\n", icon));
 303             return icon;
 304         }
 305
 306         FreeDiskObject(icon);
 307     }
 308
 309     D(bug("[ReadIcon] No icon found\n"));
 310
 311     return NULL;
 312 }
 313
 314 /* Absolute offsets for the 'only update position' mode */
 315 #define OFFSET_DO_CURRENTX      0x3a
 316 #define OFFSET_DO_CURRENTY      0x3e
 317
 318 #define is_png(ni) (ni && ni->ni_Extra.Data && ni->ni_Extra.PNG[0].Size && ni->ni_Extra.PNG[0].Offset == 0)
 319 #define is_aos(ni) (!is_png(ni))
 320
 321 BOOL __WriteIcon_WB(BPTR file, struct DiskObject *icon, struct TagItem *tags, struct IconBase *IconBase)
 322 {
 323     struct NativeIcon *ni;
 324     struct DiskObject *itmp, *oldicon = NULL;
 325     BOOL success;
 326
 327     D(bug("[%s] icon=%p\n", __func__, icon));
 328
 329     ni = GetNativeIcon(icon, IconBase);
 330    /* Fast position update, for non-PNG icons  */
 331    if (is_aos(ni) && GetTagData(ICONPUTA_OnlyUpdatePosition, FALSE, tags)) {
 332         LONG tmp;
 333         D(bug("[%s] FastUpdate x,y\n", __func__, icon));
 334         Seek(file, OFFSET_DO_CURRENTX, OFFSET_BEGINNING);
 335         tmp = AROS_LONG2BE((LONG)icon->do_CurrentX);
 336         if (Write(file, &tmp, sizeof(tmp)) == sizeof(tmp)) {
 337             Seek(file, OFFSET_DO_CURRENTY, OFFSET_BEGINNING);
 338             tmp = AROS_LONG2BE((LONG)icon->do_CurrentY);
 339             if (Write(file, &tmp, sizeof(tmp)) == sizeof(tmp)) {
 340                 return TRUE;
 341             }
 342         }
 343         return FALSE;
 344     }
 345
 346     itmp = DupDiskObject(icon, ICONDUPA_DuplicateImages, TRUE,
 347                                ICONDUPA_DuplicateImageData, TRUE,
 348                                TAG_END);
 349
 350     ni = GetNativeIcon(itmp, IconBase);
 351
 352     if (GetTagData(ICONPUTA_DropPlanarIconImage, FALSE, tags)) {
 353         itmp->do_Gadget.Flags &= ~(GFLG_GADGIMAGE | GFLG_GADGHIMAGE);
 354         itmp->do_Gadget.GadgetRender = NULL;
 355         itmp->do_Gadget.SelectRender = NULL;
 356     } else if (is_aos(ni)) {
 357         if (itmp->do_Gadget.GadgetRender == NULL) {
 358             SetIoErr(ERROR_OBJECT_WRONG_TYPE);
 359             return FALSE;
 360         }
 361     }
 362
 363     if (ni && GetTagData(ICONPUTA_DropChunkyIconImage, FALSE, tags)) {
 364         ni->ni_Image[0].ImageData = NULL;
 365         ni->ni_Image[1].ImageData = NULL;
 366     }
 367
 368     if (itmp->do_ToolTypes && GetTagData(ICONPUTA_DropNewIconToolTypes, FALSE, tags)) {
 369         int i;
 370         for (i = 0; itmp->do_ToolTypes[i] != NULL; i++) {
 371             if (strcmp(itmp->do_ToolTypes[i],"*** DON'T EDIT THE FOLLOWING LINES!! ***") == 0) {
 372                 itmp->do_ToolTypes[i] = NULL;
 373                 break;
 374             }
 375         }
 376     }
 377
 378     if (is_aos(ni) && GetTagData(ICONPUTA_OptimizeImageSpace, FALSE, tags)) {
 379         /* TODO: Compress the palette for the icon */
 380     }
 381
 382     if (is_aos(ni) && GetTagData(ICONPUTA_PreserveOldIconImages, TRUE, tags)) {
 383         oldicon = ReadIcon(file);
 384         Seek(file, 0, OFFSET_BEGINNING);
 385         if (oldicon) {
 386             itmp->do_Gadget.GadgetRender = oldicon->do_Gadget.GadgetRender;
 387             itmp->do_Gadget.SelectRender = oldicon->do_Gadget.SelectRender;
 388         }
 389     }
 390
 391     if (is_png(ni))
 392     {
 393         D(bug("[%s] Write as PNG\n", __func__));
 394         success = WriteIconPNG(file, itmp, IconBase);
 395     }
 396     else
 397     {
 398         D(bug("[%s] Write as AOS 3.5\n", __func__));
 399         success = WriteStruct(&(LB(IconBase)->dsh), (APTR) itmp, (APTR) file, IconDesc);
 400     }
 401
 402     if (oldicon)
 403         FreeDiskObject(oldicon);
 404
 405     FreeDiskObject(itmp);
 406
 407     return success;
 408 }
 409
 410 BPTR __LockObject_WB(CONST_STRPTR name, LONG mode, struct IconBase *IconBase)
 411 {
 412     BPTR lock;
 413
 414     if (name == NULL)
 415         return BNULL;
 416
 417     lock = Lock(name, mode);
 418
 419     if (lock == BNULL && (strlen(name) >= 5) && strcasecmp(name + strlen(name) - 5, ":Disk") == 0)
 420     {
 421         // FIXME: perhaps allocate buffer from heap?
 422         TEXT  buffer[256];               /* Path buffer */
 423         ULONG length = strlen(name) - 3; /* Amount to copy + NULL */
 424
 425         if (sizeof(buffer) >= length)
 426         {
 427             strlcpy(buffer, name, length);
 428             lock = Lock(buffer, mode);
 429         }
 430     }
 431
 432     return lock;
 433 }
 434
 435 VOID __UnLockObject_WB(BPTR lock, struct IconBase *IconBase)
 436 {
 437     if (lock != BNULL) UnLock(lock);
 438 }
 439
 440 CONST_STRPTR GetDefaultIconName(LONG type)
 441 {
 442     static const char * const defaultNames[] =
 443     {
 444         "Disk",         /* WBDISK    (1) */
 445         "Drawer",       /* WBDRAWER  (2) */
 446         "Tool",         /* WBTOOL    (3) */
 447         "Project",      /* WBPROJECT (4) */
 448         "Trashcan",     /* WBGARBAGE (5) */
 449         "Device",       /* WBDEVICE  (6) */
 450         "Kick",         /* WBKICK    (7) */
 451         "AppIcon"       /* WBAPPICON (8) */
 452     };
 453
 454     if (type >= 1 && type <= 8)
 455     {
 456         return defaultNames[type - 1];
 457     }
 458     else
 459     {
 460         return NULL;
 461     }
 462 }
 463
 464 /* Use the FNV-1 hash function over the object's pointer.
 465  * http://en.wikipedia.org/wiki/Fowler-Noll-Vo_hash_function
 466  */
 467 LONG CalcIconHash(struct DiskObject *dobj)
 468 {
 469     const ULONG FNV1_32_Offset = 2166136261UL;
 470     const ULONG FNV1_32_Prime  = 16777619UL;
 471     IPTR data = (IPTR)dobj;
 472     ULONG hash;
 473     int i;
 474
 475     hash = FNV1_32_Offset;
 476     for (i = 0; i < AROS_SIZEOFPTR; i++) {
 477             hash *= FNV1_32_Prime;
 478             hash ^= data & 0xff;
 479             data >>= 8;
 480     }
 481
 482     return hash & (ICONLIST_HASHSIZE-1);
 483 }
 484
 485 VOID AddIconToList(struct NativeIcon *icon, struct IconBase *IconBase)
 486 {
 487     LONG hash;
 488
 489     hash = CalcIconHash(&icon->ni_DiskObject);
 490
 491     ObtainSemaphore(&IconBase->iconlistlock);
 492     AddTail((struct List *)&IconBase->iconlists[hash], (struct Node *)&icon->ni_Node);
 493     ReleaseSemaphore(&IconBase->iconlistlock);
 494 }
 495
 496 VOID RemoveIconFromList(struct NativeIcon *icon, struct IconBase *IconBase)
 497 {
 498     ObtainSemaphore(&IconBase->iconlistlock);
 499     Remove((struct Node *)&icon->ni_Node);
 500     ReleaseSemaphore(&IconBase->iconlistlock);
 501 }
 502
 503 struct NativeIcon *GetNativeIcon(struct DiskObject *dobj, struct IconBase *IconBase)
 504 {
 505     struct NativeIcon *icon, *reticon = NULL;
 506     LONG               hash;
 507     LONG i = 0;
 508
 509     hash = CalcIconHash(dobj);
 510
 511     ObtainSemaphoreShared(&IconBase->iconlistlock);
 512     ForeachNode((struct List *)&IconBase->iconlists[hash], icon)
 513     {
 514         i++;
 515         if (dobj == &icon->ni_DiskObject)
 516         {
 517             reticon = icon;
 518             break;
 519         }
 520     }
 521     ReleaseSemaphore(&IconBase->iconlistlock);
 522
 523     return reticon;
 524 }
 525
 526
 527