workbench/libs/icon/diskobjPNGio.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /****************************************************************************************/
   7
   8 #define DTT(x)
   9
  10 #include <datatypes/datatypes.h>
  11 #include <intuition/intuition.h>
  12
  13 #include <proto/dos.h>
  14 #include <proto/alib.h>
  15 #include <proto/pngdt.h>
  16 #include <proto/datatypes.h>
  17
  18 #include <aros/bigendianio.h>
  19 #include <aros/asmcall.h>
  20
  21 #include "icon_intern.h"
  22
  23 #include <aros/debug.h>
  24
  25 #include <png.h>
  26
  27 #define ATTR_ICONX          0x80001001
  28 #define ATTR_ICONY          0x80001002
  29 #define ATTR_DRAWERX        0x80001003
  30 #define ATTR_DRAWERY        0x80001004
  31 #define ATTR_DRAWERWIDTH    0x80001005
  32 #define ATTR_DRAWERHEIGHT   0x80001006
  33 #define ATTR_DRAWERFLAGS    0x80001007
  34 #define ATTR_TOOLWINDOW     0x80001008  //OS4: STRPTR, tool window string, length including the tag
  35                                         //must be a multiple of 8
  36 #define ATTR_STACKSIZE      0x80001009
  37 #define ATTR_DEFAULTTOOL    0x8000100a
  38 #define ATTR_TOOLTYPE       0x8000100b
  39 #define ATTR_VIEWMODES      0x8000100c  //OS4 PNG use that
  40 #define ATTR_DD_CURRENTX    0x8000100d  //OS4 ULONG, drawer view X offset
  41 #define ATTR_DD_CURRENTY    0x8000100e  //OS4 ULONG, drawer view Y offset
  42 #define ATTR_TYPE           0x8000100f  //OS4 icon type (WBDISK...WBKICK)
  43 #define ATTR_FRAMELESS      0x80001010  //OS4 ULONG, frameless property
  44 #define ATTR_DRAWERFLAGS3   0x80001011  //OS4 ULONG, drawer flags
  45 #define ATTR_VIEWMODES2     0x80001012  //OS4 ULONG, drawer view modes
  46 #define ATTR_DRAWERFLAGS2   0x80001107  //written from AFA to store needed dopus Magellan settings
  47
  48 #define EFFECT_NONE      (0)
  49 #define EFFECT_LIGHTEN   (1)
  50 #define EFFECT_TINT_BLUE (2)
  51 #define EFFECT_XOR       (3)
  52
  53 #define EFFECT EFFECT_LIGHTEN
  54
  55 /****************************************************************************************/
  56
  57 /*
  58      ATTR_DRAWERFLAGS: AAABC
  59
  60      C  : 1-bit flag  : 0 = showonlyicons 1 = showallfiles
  61      B  : 1-bit flag  : 0 = viewastext    1 = view as icons
  62      AA : 2-bit value : 0 = viewbyname, 1 = viewbydata, 2 = viewbysize, 3 = viewbytype
  63 */
  64
  65 static ULONG flags_to_ddflags(ULONG flags)
  66 {
  67     ULONG ret = 0;
  68
  69     if (flags & 1)
  70     {
  71         ret = DDFLAGS_SHOWALL;
  72     }
  73     else
  74     {
  75         ret = DDFLAGS_SHOWICONS;
  76     }
  77
  78     return ret;
  79 }
  80
  81 static ULONG flags_to_ddviewmodes(ULONG flags)
  82 {
  83     ULONG ret = 0;
  84
  85     if (flags & 2)
  86     {
  87         ret = DDVM_BYICON;
  88     }
  89     else
  90     {
  91         ret = (flags >> 2) + DDVM_BYNAME;
  92     }
  93
  94     return ret;
  95 }
  96
  97 static ULONG dd_to_flags(struct DiskObject *dobj)
  98 {
  99     ULONG drawerflags = 0;
 100
 101     if (dobj->do_DrawerData->dd_Flags & DDFLAGS_SHOWALL)
 102     {
 103         drawerflags |= 1;
 104     }
 105
 106     if (dobj->do_DrawerData->dd_ViewModes == DDVM_BYICON)
 107     {
 108         drawerflags |= 2;
 109     }
 110     else
 111     {
 112         drawerflags |= ((dobj->do_DrawerData->dd_ViewModes - 2) << 2);
 113     }
 114
 115     return drawerflags;
 116 }
 117
 118 /* Returns an ARGB image.
 119  * Set &width == -1 and &height == -1 to get the size.
 120  * Otherwise, sets the image size of width & height
 121  */
 122 ULONG *ReadMemPNG(struct DiskObject *icon, APTR stream, LONG *width, LONG *height, const CONST_STRPTR *chunknames, APTR *chunkpointer, struct IconBase *IconBase)
 123 {
 124     APTR PNGBase = OpenLibrary("SYS:Classes/datatypes/png.datatype", 41);
 125     APTR handle;
 126     ULONG *argb = NULL;
 127
 128     if (!PNGBase) {
 129         D(bug("[%s] Can't open png.datatype\n", __func__));
 130         return NULL;
 131     }
 132
 133     handle = PNG_LoadImageMEM(stream, -1, chunknames, chunkpointer, TRUE);
 134     if (handle) {
 135         ULONG *src, *dst;
 136         LONG w = 0, h = 0;
 137         LONG x,y, xoff, yoff;
 138
 139         PNG_GetImageInfo(handle, &w, &h, NULL, NULL);
 140         D(bug("[%s] Dest (%d x %d), Image (%d x %d)\n", __func__,
 141                     *width, *height, w, h));
 142         if (*width == -1 && *height == -1) {
 143             *width = w;
 144             *height = h;
 145         }
 146
 147         PNG_GetImageData(handle, (APTR *)&src, NULL);
 148
 149         argb = AllocMemIcon(icon, (*width) * (*height) * sizeof(ULONG),
 150             MEMF_PUBLIC, IconBase);
 151         if (argb) {
 152             xoff = ((*width) - w)/2;
 153             yoff = ((*height) - h)/2;
 154
 155             dst = argb;
 156             for (y = 0; y < *height; y++) {
 157                 LONG sy = y + yoff;
 158
 159                 if (sy < 0)
 160                     sy = 0;
 161
 162                 if (sy >= h)
 163                     sy = h-1;
 164
 165                 for (x = 0; x < *width; x++, dst++) {
 166                     LONG sx = x + xoff;
 167
 168                     if (sx < 0)
 169                         sx = 0;
 170
 171                     if (sx >= w)
 172                         sx = w-1;
 173
 174                     *dst = src[sy*w+sx];
 175                 }
 176             }
 177         }
 178
 179         PNG_FreeImage(handle);
 180     } else {
 181         D(bug("[%s] PNG datatype can't parse data\n", __func__));
 182     }
 183
 184     CloseLibrary(PNGBase);
 185     return argb;
 186 }
 187
 188
 189 /****************************************************************************************/
 190
 191 static void GetChunkInfo(APTR stream, APTR *chunkdata, ULONG *chunksize)
 192 {
 193     png_unknown_chunkp chunkp = stream;
 194     *chunksize = chunkp->size;
 195     *chunkdata = chunkp->data;
 196 }
 197
 198 /****************************************************************************************/
 199
 200 STATIC BOOL MakePlanarImage(struct NativeIcon *icon, struct Image **img, UBYTE *src, struct IconBase *IconBase)
 201 {
 202     LONG width16 = (icon->ni_DiskObject.do_Gadget.Width + 15) & ~15;
 203     LONG bpr = width16 / 8;
 204     LONG planesize = bpr * icon->ni_DiskObject.do_Gadget.Height;
 205     LONG x, y;
 206     UWORD *p1, *p2;
 207     ULONG *s = (ULONG *) src;
 208
 209     *img = (struct Image *) AllocMemIcon(&icon->ni_DiskObject,
 210         sizeof(struct Image) + planesize * 2, MEMF_PUBLIC | MEMF_CLEAR,
 211         IconBase);
 212     if (*img == NULL)
 213         return FALSE;
 214
 215     (*img)->Width = icon->ni_DiskObject.do_Gadget.Width;
 216     (*img)->Height = icon->ni_DiskObject.do_Gadget.Height;
 217     (*img)->Depth = 2;
 218     (*img)->ImageData = (UWORD *) (*img + 1);
 219     (*img)->PlanePick = 3;
 220
 221     p1 = (UWORD *) (*img)->ImageData;
 222     p2 = p1 + planesize / 2;
 223
 224     for (y = 0; y < (*img)->Height; y++)
 225     {
 226         ULONG pixelmask = 0x8000;
 227         UWORD plane1dat = 0;
 228         UWORD plane2dat = 0;
 229
 230         for (x = 0; x < (*img)->Width; x++)
 231         {
 232             ULONG pixel = *s++;
 233
 234 #if AROS_BIG_ENDIAN
 235             if ((pixel & 0xFF000000) > 0x80000000)
 236             {
 237                 pixel = (((pixel & 0x00FF0000) >> 16) +
 238                         ((pixel & 0x0000FF00) >> 8) +
 239                         ((pixel & 0x000000FF)) +
 240                         127) / 256;
 241 #else
 242             if ((pixel & 0x000000FF) > 0x80)
 243             {
 244                 pixel = (((pixel & 0x0000FF00) >> 8) + ((pixel & 0x00FF0000) >> 16) + ((pixel & 0xFF000000) >> 24) + 127) / 256;
 245 #endif
 246
 247                 if (pixel == 3)
 248                 {
 249                     /* Col 2: White */
 250                     plane2dat |= pixelmask;
 251                 }
 252                 else if ((pixel == 2) || (pixel == 1))
 253                 {
 254                     /* Col 3: Amiga Blue */
 255                     plane1dat |= pixelmask;
 256                     plane2dat |= pixelmask;
 257                 }
 258                 else
 259                 {
 260                     /* Col 1: Black */
 261                     plane1dat |= pixelmask;
 262                 }
 263             }
 264
 265             pixelmask >>= 1;
 266             if (!pixelmask)
 267             {
 268                 pixelmask = 0x8000;
 269                 *p1++ = AROS_WORD2BE(plane1dat);
 270                 *p2++ = AROS_WORD2BE(plane2dat);
 271
 272                 plane1dat = plane2dat = 0;
 273
 274             }
 275
 276         }
 277
 278         if (pixelmask != 0x8000)
 279         {
 280             *p1++ = AROS_WORD2BE(plane1dat);
 281             *p2++ = AROS_WORD2BE(plane2dat);
 282
 283         }
 284
 285     } /* for(y = 0; y < icon->ni_Height; y++) */
 286
 287     return TRUE;
 288
 289 }
 290
 291 /****************************************************************************************/
 292
 293 STATIC BOOL MakePlanarImages(struct NativeIcon *icon, struct IconBase *IconBase)
 294 {
 295     if (!MakePlanarImage(icon, (struct Image **) &icon->ni_DiskObject.do_Gadget.GadgetRender,
 296             (UBYTE *)icon->ni_Image[0].ARGB, IconBase))
 297     {
 298         return FALSE;
 299     }
 300
 301     icon->ni_DiskObject.do_Gadget.Flags |= GFLG_GADGIMAGE;
 302
 303     if (!icon->ni_Image[1].ARGB)
 304         return TRUE;
 305
 306     if (MakePlanarImage(icon, (struct Image **) &icon->ni_DiskObject.do_Gadget.SelectRender,
 307             (UBYTE *)icon->ni_Image[1].ARGB, IconBase))
 308     {
 309         icon->ni_DiskObject.do_Gadget.Flags |= GFLG_GADGHIMAGE;
 310     }
 311
 312     return TRUE;
 313 }
 314
 315 /****************************************************************************************/
 316
 317 BOOL ReadIconPNG(struct DiskObject *dobj, BPTR file, struct IconBase *IconBase)
 318 {
 319     static CONST_STRPTR const chunknames[] =
 320     {
 321         "icOn",
 322         NULL
 323     };
 324     APTR chunkpointer[] =
 325     {
 326         NULL,
 327         NULL
 328     };
 329
 330     struct NativeIcon  *icon;
 331     ULONG               filesize;
 332     APTR                data;
 333
 334     icon = NATIVEICON(dobj);
 335
 336     D(bug("%s: File stream %p\n", __func__, file));
 337
 338     if (Seek(file, 0, OFFSET_END) < 0) return FALSE;
 339     if ((filesize = Seek(file, 0, OFFSET_BEGINNING)) < 0) return FALSE;
 340
 341     D(bug("[%s] Inspecting a %d byte file\n", __func__, filesize));
 342
 343     /* Need a copy of whole file in memory for icon saving :-\ Because
 344        that should save file back as it was, only with modified or new
 345        icOn chunk. And it must also work when loading an icon and then
 346        saving it using another name. */
 347
 348     data = AllocMemIcon(&icon->ni_DiskObject, filesize, MEMF_PUBLIC,
 349         IconBase);
 350     if (!data)
 351         return FALSE;
 352
 353     if (Read(file, data, filesize) != filesize)
 354     {
 355         D(bug("[%s] Can't read from file\n", __func__));
 356         return FALSE;
 357     }
 358
 359     icon->ni_Extra.Data = data;
 360     icon->ni_Extra.Size = filesize;
 361
 362     icon->ni_Extra.PNG[0].Offset = 0;
 363     icon->ni_Extra.PNG[0].Size = filesize;
 364     {
 365         ULONG width = ~0, height = ~0;
 366
 367         icon->ni_Image[0].ARGB = ReadMemPNG(&icon->ni_DiskObject, icon->ni_Extra.Data + icon->ni_Extra.PNG[0].Offset, &width, &height, chunknames, chunkpointer, IconBase);
 368         if (icon->ni_Image[0].ARGB == NULL) {
 369             D(bug("[%s] Can't parse PNG image at 0\n", __func__));
 370             return FALSE;
 371         }
 372
 373         icon->ni_Face.Width  = width;
 374         icon->ni_Face.Height = height;
 375         icon->ni_Face.Aspect = ICON_ASPECT_RATIO_UNKNOWN;
 376
 377         #define DO(x) (&x->ni_DiskObject)
 378
 379         DO(icon)->do_Magic          = WB_DISKMAGIC;
 380         DO(icon)->do_Version        = (WB_DISKVERSION << 8) | WB_DISKREVISION;
 381         DO(icon)->do_Type           = 0;  /* Invalid */
 382         DO(icon)->do_CurrentX       = NO_ICON_POSITION;
 383         DO(icon)->do_CurrentY       = NO_ICON_POSITION;
 384         DO(icon)->do_Gadget.Width   = width;
 385         DO(icon)->do_Gadget.Height  = height;
 386         DO(icon)->do_StackSize      = AROS_STACKSIZE;
 387
 388         if (chunkpointer[0])
 389         {
 390             UBYTE *chunkdata;
 391             ULONG  chunksize;
 392             ULONG  ttnum = 0;
 393             ULONG  ttarraysize = 0;
 394             BOOL   ok = TRUE;
 395
 396             GetChunkInfo(chunkpointer[0], (APTR *)&chunkdata, &chunksize);
 397
 398             while(chunksize >= 4)
 399             {
 400                 ULONG attr;
 401                 IPTR  val = 0;
 402                 BOOL  need_drawerdata = FALSE;
 403
 404                 attr = (chunkdata[0] << 24) | (chunkdata[1] << 16) | (chunkdata[2] << 8) | chunkdata[3];
 405                 chunksize -=4;
 406                 chunkdata += 4;
 407
 408                 switch(attr)
 409                 {
 410                     case ATTR_DRAWERX:
 411                     case ATTR_DRAWERY:
 412                     case ATTR_DRAWERWIDTH:
 413                     case ATTR_DRAWERHEIGHT:
 414                     case ATTR_DRAWERFLAGS:
 415                     case ATTR_DRAWERFLAGS2:
 416                     case ATTR_DRAWERFLAGS3:
 417                     case ATTR_VIEWMODES:
 418                     case ATTR_VIEWMODES2:
 419                     case ATTR_DD_CURRENTX:
 420                     case ATTR_DD_CURRENTY:
 421                         need_drawerdata = TRUE;
 422                         /* Fall through */
 423
 424                     case ATTR_ICONX:
 425                     case ATTR_ICONY:
 426                     case ATTR_STACKSIZE:
 427                     case ATTR_TYPE:
 428                     case ATTR_FRAMELESS:
 429                         if (chunksize >= 4)
 430                         {
 431                             val = (chunkdata[0] << 24) | (chunkdata[1] << 16) | (chunkdata[2] << 8) | chunkdata[3];
 432                             chunksize -=4;
 433                             chunkdata += 4;
 434                         }
 435                         else
 436                         {
 437                             ok = FALSE;
 438                         }
 439                         break;
 440
 441                     /* case ATTR_UNKNOWN: */
 442                     case ATTR_DEFAULTTOOL:
 443                     case ATTR_TOOLTYPE:
 444                         val = (IPTR)chunkdata;
 445                         chunksize -= strlen((char *)val) + 1;
 446                         chunkdata += strlen((char *)val) + 1;
 447
 448                         if (chunksize < 0)
 449                         {
 450                             ok = FALSE;
 451                         }
 452                         break;
 453
 454                     default:
 455                         /* Unknown attribute/tag. Impossible to handle correctly
 456                            if we don't know if it's a string attribute or not. */
 457                         ok = FALSE;
 458                         break;
 459
 460                 } /* switch(attr) */
 461
 462                 if (!ok) break;
 463
 464                 if (need_drawerdata && !(DO(icon)->do_DrawerData))
 465                 {
 466                     DO(icon)->do_DrawerData =
 467                         AllocMemIcon(DO(icon), sizeof(struct DrawerData),
 468                             MEMF_PUBLIC | MEMF_CLEAR, IconBase);
 469                     if (!(DO(icon)->do_DrawerData))
 470                     {
 471                         ok = FALSE;
 472                         break;
 473                     }
 474
 475                     DO(icon)->do_DrawerData->dd_NewWindow.LeftEdge = 20;
 476                     DO(icon)->do_DrawerData->dd_NewWindow.TopEdge  = 20;
 477                     DO(icon)->do_DrawerData->dd_NewWindow.Width    = 300;
 478                     DO(icon)->do_DrawerData->dd_NewWindow.Height   = 200;
 479             DO(icon)->do_Gadget.UserData = (APTR)1; /* See DupDiskObject logic */
 480                 }
 481
 482                 switch(attr)
 483                 {
 484                     case ATTR_ICONX:
 485                         DO(icon)->do_CurrentX = val;
 486                         break;
 487
 488                     case ATTR_ICONY:
 489                         DO(icon)->do_CurrentY = val;
 490                         break;
 491
 492                     case ATTR_STACKSIZE:
 493                         DO(icon)->do_StackSize = val;
 494                         break;
 495
 496                     case ATTR_DRAWERX:
 497                         DO(icon)->do_DrawerData->dd_NewWindow.LeftEdge = (WORD)val;
 498                         break;
 499
 500                     case ATTR_DRAWERY:
 501                         DO(icon)->do_DrawerData->dd_NewWindow.TopEdge = (WORD)val;
 502                         break;
 503
 504                     case ATTR_DRAWERWIDTH:
 505                         DO(icon)->do_DrawerData->dd_NewWindow.Width = (WORD)val;
 506                         break;
 507
 508                     case ATTR_DRAWERHEIGHT:
 509                         DO(icon)->do_DrawerData->dd_NewWindow.Height = (WORD)val;
 510                         break;
 511
 512                     case ATTR_DRAWERFLAGS:
 513                         DO(icon)->do_DrawerData->dd_Flags     = flags_to_ddflags(val);
 514                         DO(icon)->do_DrawerData->dd_ViewModes = flags_to_ddviewmodes(val);
 515                         break;
 516
 517                     case ATTR_DEFAULTTOOL:
 518                         DO(icon)->do_DefaultTool =
 519                             AllocMemIcon(DO(icon), strlen((char *)val) + 1,
 520                                 MEMF_PUBLIC | MEMF_CLEAR, IconBase);
 521                         if (DO(icon)->do_DefaultTool)
 522                         {
 523                             strcpy(DO(icon)->do_DefaultTool, (char *)val);
 524                         }
 525                         else
 526                         {
 527                             ok = FALSE;
 528                         }
 529                         break;
 530                     case ATTR_FRAMELESS:
 531                         NATIVEICON(icon)->ni_Frameless = val ? TRUE : FALSE;
 532                         break;
 533
 534                     case ATTR_TOOLTYPE:
 535                         ttnum++;
 536
 537                         D(bug("[Icon.PNG] Got tooltype number %u : %s\n", ttnum - 1, val));
 538
 539                         if (ttarraysize < ttnum + 1)
 540                         {
 541                             STRPTR *old_tooltypes = DO(icon)->do_ToolTypes;
 542
 543                             ttarraysize += 10;
 544
 545                             DO(icon)->do_ToolTypes =
 546                                 AllocMemIcon(DO(icon),
 547                                     ttarraysize * sizeof(APTR),
 548                                     MEMF_PUBLIC | MEMF_CLEAR, IconBase);
 549                             if (DO(icon)->do_ToolTypes)
 550                             {
 551                                 D(bug("[Icon.PNG] Allocated array of %u entries @ 0x%p (old 0x%p)\n", ttarraysize, DO(icon)->do_ToolTypes, old_tooltypes));
 552                                 if (old_tooltypes)
 553                                 {
 554                                     CopyMemQuick(old_tooltypes, DO(icon)->do_ToolTypes, (ttnum - 1) * sizeof(APTR));
 555
 556                                     /* TODO: Free old array */
 557                                 }
 558                             }
 559                             else
 560                             {
 561                                 ok = FALSE;
 562                             }
 563                         }
 564
 565                         if (!ok) break;
 566
 567                         DO(icon)->do_ToolTypes[ttnum - 1] =
 568                             AllocMemIcon(DO(icon), strlen((char *)val) + 1,
 569                             MEMF_PUBLIC | MEMF_CLEAR, IconBase);
 570                         if (DO(icon)->do_ToolTypes[ttnum - 1])
 571                         {
 572                             strcpy(DO(icon)->do_ToolTypes[ttnum - 1], (char *)val);
 573                         }
 574                         else
 575                         {
 576                             ok = FALSE;
 577                         }
 578                         break;
 579
 580                 } /* switch(attr) */
 581
 582                 if (!ok) break;
 583
 584             } /* while(chunksize >= 4) */
 585
 586             if (!ok)
 587             {
 588                 D(bug("=== Failure during icOn chunk parsing ===\n"));
 589                 FreeIconPNG(&icon->ni_DiskObject, IconBase);
 590                 return FALSE;
 591             }
 592
 593
 594         } /* if (chunkpointer[0]) */
 595
 596         #undef DO
 597
 598         /*
 599          * FIXME: Someone killed PNG Icon do_Type detection here which causes
 600          *        following lines to always free DrawerData even when it
 601          *        shouldn't be freed (only possible to know if do_Type is
 602          *        known). So for now following lines disabled and DrawerData
 603          *        is always kept (even when it shouldn't).
 604          */
 605
 606 #if 0
 607         if (icon->ni_DiskObject.do_DrawerData &&
 608             (icon->ni_DiskObject.do_Type != WBDISK) &&
 609             (icon->ni_DiskObject.do_Type != WBDRAWER) &&
 610             (icon->ni_DiskObject.do_Type != WBGARBAGE))
 611         {
 612             FreePooled(pool, icon->ni_DiskObject.do_DrawerData, sizeof(struct DrawerData));
 613             icon->ni_DiskObject.do_DrawerData = NULL;
 614         }
 615 #endif
 616
 617     } /**/
 618
 619     /* Look for a possible 2nd PNG image attached onto the first one */
 620     {
 621         UBYTE *filepos = icon->ni_Extra.Data + icon->ni_Extra.PNG[0].Offset + 8;
 622         BOOL done = FALSE;
 623
 624         while(!done && filepos < ((UBYTE *)icon->ni_Extra.Data + icon->ni_Extra.Size))
 625         {
 626             ULONG chunksize = (filepos[0] << 24) | (filepos[1] << 16) |
 627                               (filepos[2] << 8) | filepos[3];
 628             ULONG chunktype = (filepos[4] << 24) | (filepos[5] << 16) |
 629                               (filepos[6] << 8) | filepos[7];
 630
 631             chunksize += 12;
 632
 633             if (chunktype == MAKE_ID('I', 'E', 'N', 'D'))
 634             {
 635                 done = TRUE;
 636             }
 637
 638             filepos += chunksize;
 639         }
 640
 641         if (filepos + 8 < (UBYTE *)icon->ni_Extra.Data + icon->ni_Extra.Size)
 642         {
 643             ULONG offset = filepos - (UBYTE *)icon->ni_Extra.Data;
 644
 645             icon->ni_Extra.PNG[0].Size = offset;
 646             icon->ni_Extra.PNG[1].Offset = offset;
 647             icon->ni_Extra.PNG[1].Size = (filesize - icon->ni_Extra.PNG[0].Size);
 648             icon->ni_Image[1].ARGB = ReadMemPNG(&icon->ni_DiskObject, filepos, &icon->ni_Face.Width, &icon->ni_Face.Height, NULL, NULL, IconBase);
 649         }
 650
 651     } /**/
 652
 653     /* If there's no image for selected-state, generate one */
 654     if (!icon->ni_Image[1].ARGB)
 655     {
 656         ULONG size = icon->ni_Face.Width * icon->ni_Face.Height;
 657
 658         if ((icon->ni_Image[1].ARGB =
 659             AllocMemIcon(&icon->ni_DiskObject, size * sizeof(ULONG),
 660                 MEMF_PUBLIC, IconBase)))
 661         {
 662             ULONG *src = (ULONG *)icon->ni_Image[0].ARGB;
 663             ULONG *dst = (ULONG *)icon->ni_Image[1].ARGB;
 664
 665             while(size--)
 666             {
 667                 ULONG pixel = *src++;
 668
 669                 /* Effects like in changetoselectediconcolor.c */
 670
 671         #if EFFECT == EFFECT_LIGHTEN
 672             #if AROS_BIG_ENDIAN
 673                 pixel = (pixel & 0xFF000000) +
 674                         ((pixel >> 1) & 0x007F7F7F) +
 675                         0x00808080;
 676             #else
 677                 pixel = (pixel & 0x000000FF) +
 678                         ((pixel >> 1) & 0x7F7F7F00) +
 679                         0x80808000;
 680             #endif
 681         #elif EFFECT == EFFECT_TINT_BLUE
 682             #if AROS_BIG_ENDIAN
 683                 pixel = (pixel & 0xFF000000) +
 684                         ((pixel >> 1) & 0x007F7F7F) +
 685                         0x00000080;
 686             #else
 687                 pixel = (pixel & 0x000000FF) +
 688                         ((pixel >> 1) & 0x7F7F7F00) +
 689                         0x80000000;
 690             #endif
 691
 692         #elif EFFECT == EFFECT_XOR
 693             #if AROS_BIG_ENDIAN
 694                 pixel = (pixel & 0xFF000000) +
 695                         ((pixel & 0x00FFFFFF) ^ 0x00FFFFFF);
 696             #else
 697                 pixel = (pixel & 0x000000FF) +
 698                         ((pixel & 0xFFFFFF00) ^ 0xFFFFFF00);
 699             #endif
 700         #endif
 701                 *dst++ = pixel;
 702             }
 703         }
 704     }
 705
 706     /*
 707      * Support old-style AROS PNG icons. 3rd party applications
 708      * will still be using them.
 709      */
 710
 711     if (!MakePlanarImages(icon, IconBase))
 712     {
 713         D(bug("Planar image creation failed\n"));
 714         FreeIconPNG(&icon->ni_DiskObject, IconBase);
 715         return FALSE;
 716     }
 717
 718     return TRUE;
 719
 720 }
 721
 722 /****************************************************************************************/
 723
 724 STATIC VOID MakeCRCTable(struct IconBase *IconBase)
 725 {
 726     unsigned long c;
 727     int n, k;
 728
 729     IconBase->ib_CRCTable = AllocMem(256 * sizeof(ULONG), MEMF_ANY);
 730     if (!IconBase->ib_CRCTable)
 731         return;
 732     for (n = 0; n < 256; n++)
 733     {
 734         c = (unsigned long) n;
 735         for (k = 0; k < 8; k++)
 736         {
 737             if (c & 1)
 738                 c = 0xedb88320L ^ (c >> 1);
 739             else
 740                 c = c >> 1;
 741         }
 742         IconBase->ib_CRCTable[n] = c;
 743     }
 744 }
 745
 746 /****************************************************************************************/
 747
 748 STATIC ULONG UpdateCRC(ULONG crc, UBYTE *buf, ULONG len, struct IconBase *IconBase)
 749 {
 750     ULONG c = crc;
 751     ULONG n;
 752
 753     for (n = 0; n < len; n++)
 754     {
 755         c = IconBase->ib_CRCTable[(c ^ buf[n]) & 0xff] ^ (c >> 8);
 756     }
 757
 758     return c;
 759
 760 }
 761
 762 /****************************************************************************************/
 763
 764 STATIC BOOL WriteIconAttr(BPTR file, ULONG id, ULONG val, ULONG *chunksize,
 765                           ULONG *crc, struct IconBase *IconBase)
 766 {
 767     UBYTE buf[8];
 768
 769     buf[0] = id >> 24;
 770     buf[1] = id >> 16;
 771     buf[2] = id >> 8;
 772     buf[3] = id;
 773     buf[4] = val >> 24;
 774     buf[5] = val >> 16;
 775     buf[6] = val >> 8;
 776     buf[7] = val;
 777
 778     if (Write(file, buf, 8) != 8) return FALSE;
 779
 780     *chunksize += 8;
 781     *crc = UpdateCRC(*crc, buf, 8, IconBase);
 782     return TRUE;
 783 }
 784
 785 /****************************************************************************************/
 786
 787 STATIC BOOL WriteIconStrAttr(BPTR file, ULONG id, char *val, ULONG *chunksize,
 788                              ULONG *crc, struct IconBase *IconBase)
 789 {
 790     UBYTE buf[4];
 791     ULONG len = strlen(val) + 1;
 792
 793     buf[0] = id >> 24;
 794     buf[1] = id >> 16;
 795     buf[2] = id >> 8;
 796     buf[3] = id;
 797
 798     if (Write(file, buf, 4) != 4) return FALSE;
 799     *crc = UpdateCRC(*crc, buf, 4, IconBase);
 800
 801     if (Write(file, val, len) != len) return FALSE;
 802     *crc = UpdateCRC(*crc, val, len, IconBase);
 803
 804     *chunksize += 4 + len;
 805
 806     return TRUE;
 807 }
 808
 809 /****************************************************************************************/
 810
 811 STATIC BOOL WriteIconChunk(BPTR file, struct DiskObject *dobj, struct IconBase *IconBase)
 812 {
 813     ULONG crc = 0xFFFFFFFF;
 814     ULONG chunksize = 0;
 815     ULONG sizeseek = Seek(file, 0, OFFSET_CURRENT);
 816     UBYTE buf[] = {0x12, 0x34, 0x56, 0x78, 'i', 'c', 'O', 'n'};
 817
 818     if (sizeseek < 0) return FALSE;
 819
 820     /* Write Chunk size + chunk type */
 821     if (Write(file, buf, 8) != 8) return FALSE;
 822
 823     crc = UpdateCRC(crc, buf + 4, 4, IconBase); /* chunksize is excluded from CRC */
 824
 825     /* Write Frameless */
 826     if (!WriteIconAttr(file, ATTR_FRAMELESS, NATIVEICON(dobj)->ni_Frameless, &chunksize, &crc, IconBase))
 827     {
 828         return FALSE;
 829     }
 830
 831     /* Write Stack Size */
 832
 833     if (!WriteIconAttr(file, ATTR_STACKSIZE, dobj->do_StackSize, &chunksize, &crc, IconBase))
 834     {
 835         return FALSE;
 836     }
 837
 838     /* Write Icon X Position */
 839     if (dobj->do_CurrentX != NO_ICON_POSITION)
 840     {
 841         if (!WriteIconAttr(file, ATTR_ICONX, dobj->do_CurrentX, &chunksize, &crc, IconBase))
 842         {
 843             return FALSE;
 844         }
 845     }
 846
 847     /* Write Icon Y Position */
 848     if (dobj->do_CurrentY != NO_ICON_POSITION)
 849     {
 850         if (!WriteIconAttr(file, ATTR_ICONY, dobj->do_CurrentY, &chunksize, &crc, IconBase))
 851         {
 852             return FALSE;
 853         }
 854     }
 855
 856     if (dobj->do_DrawerData)
 857     {
 858         if (!WriteIconAttr(file, ATTR_DRAWERX, dobj->do_DrawerData->dd_NewWindow.LeftEdge,
 859             &chunksize, &crc, IconBase))
 860         {
 861             return FALSE;
 862         }
 863
 864         if (!WriteIconAttr(file, ATTR_DRAWERY, dobj->do_DrawerData->dd_NewWindow.TopEdge,
 865             &chunksize, &crc, IconBase))
 866         {
 867             return FALSE;
 868         }
 869
 870         if (!WriteIconAttr(file, ATTR_DRAWERWIDTH, dobj->do_DrawerData->dd_NewWindow.Width,
 871             &chunksize, &crc, IconBase))
 872         {
 873             return FALSE;
 874         }
 875
 876         if (!WriteIconAttr(file, ATTR_DRAWERHEIGHT, dobj->do_DrawerData->dd_NewWindow.Height,
 877             &chunksize, &crc, IconBase))
 878         {
 879             return FALSE;
 880         }
 881
 882         if (!WriteIconAttr(file, ATTR_DRAWERFLAGS, dd_to_flags(dobj),
 883             &chunksize, &crc, IconBase))
 884         {
 885             return FALSE;
 886         }
 887
 888     } /* if (dobj->do_DrawerData) */
 889
 890     if (dobj->do_DefaultTool)
 891     {
 892         if (!WriteIconStrAttr(file, ATTR_DEFAULTTOOL, dobj->do_DefaultTool,
 893             &chunksize, &crc, IconBase))
 894         {
 895             return FALSE;
 896         }
 897
 898     }
 899
 900     if (dobj->do_ToolTypes)
 901     {
 902         STRPTR *tt = (STRPTR *)dobj->do_ToolTypes;
 903
 904         for(tt = (STRPTR *)dobj->do_ToolTypes; *tt; tt++)
 905         {
 906             if (!WriteIconStrAttr(file, ATTR_TOOLTYPE, *tt, &chunksize,
 907                                   &crc, IconBase))
 908             {
 909                 return FALSE;
 910             }
 911         }
 912     }
 913
 914     /* Write CRC */
 915
 916     crc ^= 0xFFFFFFFF;
 917     buf[0] = crc >> 24;
 918     buf[1] = crc >> 16;
 919     buf[2] = crc >> 8;
 920     buf[3] = crc;
 921     if (Write(file, buf, 4) != 4) return FALSE;
 922
 923     /* Trim any garbage at end of file */
 924     if (SetFileSize(file, 0, OFFSET_CURRENT) < 0) return FALSE;
 925
 926     /* Write chunk's size */
 927     if (Seek(file, sizeseek, OFFSET_BEGINNING) < 0) return FALSE;
 928
 929     buf[0] = chunksize >> 24;
 930     buf[1] = chunksize >> 16;
 931     buf[2] = chunksize >> 8;
 932     buf[3] = chunksize;
 933     if (Write(file, buf, 4) != 4) return FALSE;
 934
 935     if (Seek(file, 0, OFFSET_END) < 0) return FALSE;
 936
 937     return TRUE;
 938 }
 939
 940 /****************************************************************************************/
 941
 942 BOOL WriteIconPNG(BPTR file, struct DiskObject *dobj, struct IconBase *IconBase)
 943 {
 944     struct NativeIcon   *nativeicon = NATIVEICON(dobj);
 945     UBYTE               *mempos = nativeicon->ni_Extra.Data + nativeicon->ni_Extra.PNG[0].Offset;
 946     BOOL                 done = FALSE;
 947
 948     D(bug("%s: ni=%p, ni->ni_Extra.Data = %p\n", __func__, nativeicon, nativeicon->ni_Extra.Data));
 949     if (nativeicon->ni_Extra.Data == NULL)
 950         return FALSE;
 951
 952     ObtainSemaphore(&IconBase->iconlistlock);
 953     if (!IconBase->ib_CRCTable)
 954         MakeCRCTable(IconBase);
 955     ReleaseSemaphore(&IconBase->iconlistlock);
 956     if (!IconBase->ib_CRCTable)
 957         return FALSE;
 958
 959     /* Write PNG header */
 960     if (Write(file, mempos, 8) != 8) return FALSE;
 961
 962     mempos += 8;
 963
 964     while(!done)
 965     {
 966         ULONG chunksize = (mempos[0] << 24) | (mempos[1] << 16) |
 967                           (mempos[2] << 8) | mempos[3];
 968         ULONG chunktype = (mempos[4] << 24) | (mempos[5] << 16) |
 969                           (mempos[6] << 8) | mempos[7];
 970
 971         chunksize += 12;
 972
 973         if (chunktype == MAKE_ID('I', 'E', 'N', 'D'))
 974         {
 975             if (!WriteIconChunk(file, dobj, IconBase)) return FALSE;
 976             done = TRUE;
 977         }
 978
 979         if (chunktype != MAKE_ID('i', 'c', 'O', 'n'))
 980         {
 981             if (Write(file, mempos, chunksize) != chunksize)
 982             {
 983                 return FALSE;
 984             }
 985         }
 986
 987         mempos += chunksize;
 988
 989     }
 990
 991     if (nativeicon->ni_Extra.PNG[1].Offset > 0)
 992     {
 993         ULONG size = nativeicon->ni_Extra.PNG[1].Size;
 994
 995         /* 2nd PNG Image attached */
 996
 997         if (Write(file, nativeicon->ni_Extra.Data + nativeicon->ni_Extra.PNG[1].Offset, size) != size) return FALSE;
 998     }
 999
1000     return TRUE;
1001 }
1002
1003 /****************************************************************************************/
1004
1005 VOID FreeIconPNG(struct DiskObject *dobj, struct IconBase *IconBase)
1006 {
1007 }
1008
1009 /****************************************************************************************/