workbench/libs/icon/diskobjPNGio.c

   1 /*
   2     Copyright © 1995-2011, 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/png.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), MEMF_PUBLIC);
 150         if (argb) {
 151             xoff = ((*width) - w)/2;
 152             yoff = ((*height) - h)/2;
 153
 154             dst = argb;
 155             for (y = 0; y < *height; y++) {
 156                 LONG sy = y + yoff;
 157
 158                 if (sy < 0)
 159                     sy = 0;
 160
 161                 if (sy >= h)
 162                     sy = h-1;
 163
 164                 for (x = 0; x < *width; x++, dst++) {
 165                     LONG sx = x + xoff;
 166
 167                     if (sx < 0)
 168                         sx = 0;
 169
 170                     if (sx >= w)
 171                         sx = w-1;
 172
 173                     *dst = src[sy*w+sx];
 174                 }
 175             }
 176         }
 177
 178         PNG_FreeImage(handle);
 179     } else {
 180         D(bug("[%s] PNG datatype can't parse data\n", __func__));
 181     }
 182
 183     CloseLibrary(PNGBase);
 184     return argb;
 185 }
 186
 187
 188 /****************************************************************************************/
 189
 190 static void GetChunkInfo(APTR stream, APTR *chunkdata, ULONG *chunksize)
 191 {
 192     png_unknown_chunkp chunkp = stream;
 193     *chunksize = chunkp->size;
 194     *chunkdata = chunkp->data;
 195 }
 196
 197 BOOL ReadIconPNG(struct DiskObject *dobj, BPTR file, struct IconBase *IconBase)
 198 {
 199     static CONST_STRPTR const chunknames[] =
 200     {
 201         "icOn",
 202         NULL
 203     };
 204     APTR chunkpointer[] =
 205     {
 206         NULL,
 207         NULL
 208     };
 209
 210     struct NativeIcon  *icon;
 211     ULONG               filesize;
 212     APTR                data;
 213
 214     icon = NATIVEICON(dobj);
 215
 216     D(bug("%s: File stream %p\n", __func__, file));
 217
 218     if (Seek(file, 0, OFFSET_END) < 0) return FALSE;
 219     if ((filesize = Seek(file, 0, OFFSET_BEGINNING)) < 0) return FALSE;
 220
 221     D(bug("[%s] Inspecting a %d byte file\n", __func__, filesize));
 222
 223     /* Need a copy of whole file in memory for icon saving :-\ Because
 224        that should save file back as it was, only with modified or new
 225        icOn chunk. And it must also work when loading an icon and then
 226        saving it using another name. */
 227
 228     data = AllocMemIcon(&icon->ni_DiskObject, filesize, MEMF_PUBLIC);
 229     if (!data)
 230         return FALSE;
 231
 232     if (Read(file, data, filesize) != filesize)
 233     {
 234         D(bug("[%s] Can't read from file\n", __func__));
 235         return FALSE;
 236     }
 237
 238     icon->ni_Extra.Data = data;
 239     icon->ni_Extra.Size = filesize;
 240
 241     icon->ni_Extra.PNG[0].Offset = 0;
 242     icon->ni_Extra.PNG[0].Size = filesize;
 243     {
 244         ULONG width = ~0, height = ~0;
 245
 246         icon->ni_Image[0].ARGB = ReadMemPNG(&icon->ni_DiskObject, icon->ni_Extra.Data + icon->ni_Extra.PNG[0].Offset, &width, &height, chunknames, chunkpointer, IconBase);
 247         if (icon->ni_Image[0].ARGB == NULL) {
 248             D(bug("[%s] Can't parse PNG image at 0\n", __func__));
 249             return FALSE;
 250         }
 251
 252         icon->ni_Face.Width  = width;
 253         icon->ni_Face.Height = height;
 254         icon->ni_Face.Aspect = ICON_ASPECT_RATIO_UNKNOWN;
 255
 256         #define DO(x) (&x->ni_DiskObject)
 257
 258         DO(icon)->do_Magic          = WB_DISKMAGIC;
 259         DO(icon)->do_Version        = (WB_DISKVERSION << 8) | WB_DISKREVISION;
 260         DO(icon)->do_Type           = 0;  /* Invalid */
 261         DO(icon)->do_CurrentX       = NO_ICON_POSITION;
 262         DO(icon)->do_CurrentY       = NO_ICON_POSITION;
 263         DO(icon)->do_Gadget.Width   = width;
 264         DO(icon)->do_Gadget.Height  = height;
 265         DO(icon)->do_StackSize      = AROS_STACKSIZE;
 266
 267         if (chunkpointer[0])
 268         {
 269             UBYTE *chunkdata;
 270             ULONG  chunksize;
 271             ULONG  ttnum = 0;
 272             ULONG  ttarraysize = 0;
 273             BOOL   ok = TRUE;
 274
 275             GetChunkInfo(chunkpointer[0], (APTR *)&chunkdata, &chunksize);
 276
 277             while(chunksize >= 4)
 278             {
 279                 ULONG attr;
 280                 IPTR  val = 0;
 281                 BOOL  need_drawerdata = FALSE;
 282
 283                 attr = (chunkdata[0] << 24) | (chunkdata[1] << 16) | (chunkdata[2] << 8) | chunkdata[3];
 284                 chunksize -=4;
 285                 chunkdata += 4;
 286
 287                 switch(attr)
 288                 {
 289                     case ATTR_DRAWERX:
 290                     case ATTR_DRAWERY:
 291                     case ATTR_DRAWERWIDTH:
 292                     case ATTR_DRAWERHEIGHT:
 293                     case ATTR_DRAWERFLAGS:
 294                     case ATTR_DRAWERFLAGS2:
 295                     case ATTR_DRAWERFLAGS3:
 296                     case ATTR_VIEWMODES:
 297                     case ATTR_VIEWMODES2:
 298                     case ATTR_DD_CURRENTX:
 299                     case ATTR_DD_CURRENTY:
 300                         need_drawerdata = TRUE;
 301                         /* Fall through */
 302
 303                     case ATTR_ICONX:
 304                     case ATTR_ICONY:
 305                     case ATTR_STACKSIZE:
 306                     case ATTR_TYPE:
 307                     case ATTR_FRAMELESS:
 308                         if (chunksize >= 4)
 309                         {
 310                             val = (chunkdata[0] << 24) | (chunkdata[1] << 16) | (chunkdata[2] << 8) | chunkdata[3];
 311                             chunksize -=4;
 312                             chunkdata += 4;
 313                         }
 314                         else
 315                         {
 316                             ok = FALSE;
 317                         }
 318                         break;
 319
 320                     /* case ATTR_UNKNOWN: */
 321                     case ATTR_DEFAULTTOOL:
 322                     case ATTR_TOOLTYPE:
 323                         val = (IPTR)chunkdata;
 324                         chunksize -= strlen((char *)val) + 1;
 325                         chunkdata += strlen((char *)val) + 1;
 326
 327                         if (chunksize < 0)
 328                         {
 329                             ok = FALSE;
 330                         }
 331                         break;
 332
 333                     default:
 334                         /* Unknown attribute/tag. Impossible to handle correctly
 335                            if we don't know if it's a string attribute or not. */
 336                         ok = FALSE;
 337                         break;
 338
 339                 } /* switch(attr) */
 340
 341                 if (!ok) break;
 342
 343                 if (need_drawerdata && !(DO(icon)->do_DrawerData))
 344                 {
 345                     DO(icon)->do_DrawerData = AllocMemIcon(DO(icon), sizeof(struct DrawerData), MEMF_PUBLIC | MEMF_CLEAR);
 346                     if (!(DO(icon)->do_DrawerData))
 347                     {
 348                         ok = FALSE;
 349                         break;
 350                     }
 351
 352                     DO(icon)->do_DrawerData->dd_NewWindow.LeftEdge = 20;
 353                     DO(icon)->do_DrawerData->dd_NewWindow.TopEdge  = 20;
 354                     DO(icon)->do_DrawerData->dd_NewWindow.Width    = 300;
 355                     DO(icon)->do_DrawerData->dd_NewWindow.Height   = 200;
 356             DO(icon)->do_Gadget.UserData = (APTR)1; /* See DupDiskObject logic */
 357                 }
 358
 359                 switch(attr)
 360                 {
 361                     case ATTR_ICONX:
 362                         DO(icon)->do_CurrentX = val;
 363                         break;
 364
 365                     case ATTR_ICONY:
 366                         DO(icon)->do_CurrentY = val;
 367                         break;
 368
 369                     case ATTR_STACKSIZE:
 370                         DO(icon)->do_StackSize = val;
 371                         break;
 372
 373                     case ATTR_DRAWERX:
 374                         DO(icon)->do_DrawerData->dd_NewWindow.LeftEdge = (WORD)val;
 375                         break;
 376
 377                     case ATTR_DRAWERY:
 378                         DO(icon)->do_DrawerData->dd_NewWindow.TopEdge = (WORD)val;
 379                         break;
 380
 381                     case ATTR_DRAWERWIDTH:
 382                         DO(icon)->do_DrawerData->dd_NewWindow.Width = (WORD)val;
 383                         break;
 384
 385                     case ATTR_DRAWERHEIGHT:
 386                         DO(icon)->do_DrawerData->dd_NewWindow.Height = (WORD)val;
 387                         break;
 388
 389                     case ATTR_DRAWERFLAGS:
 390                         DO(icon)->do_DrawerData->dd_Flags     = flags_to_ddflags(val);
 391                         DO(icon)->do_DrawerData->dd_ViewModes = flags_to_ddviewmodes(val);
 392                         break;
 393
 394                     case ATTR_DEFAULTTOOL:
 395                         DO(icon)->do_DefaultTool = AllocMemIcon(DO(icon), strlen((char *)val) + 1, MEMF_PUBLIC | MEMF_CLEAR);
 396                         if (DO(icon)->do_DefaultTool)
 397                         {
 398                             strcpy(DO(icon)->do_DefaultTool, (char *)val);
 399                         }
 400                         else
 401                         {
 402                             ok = FALSE;
 403                         }
 404                         break;
 405                     case ATTR_FRAMELESS:
 406                         NATIVEICON(icon)->ni_Frameless = val ? TRUE : FALSE;
 407                         break;
 408
 409                     case ATTR_TOOLTYPE:
 410                         ttnum++;
 411
 412                         D(bug("[Icon.PNG] Got tooltype number %u : %s\n", ttnum - 1, val));
 413
 414                         if (ttarraysize < ttnum + 1)
 415                         {
 416                             STRPTR *old_tooltypes = DO(icon)->do_ToolTypes;
 417
 418                             ttarraysize += 10;
 419
 420                             DO(icon)->do_ToolTypes = AllocMemIcon(DO(icon), ttarraysize * sizeof(APTR), MEMF_PUBLIC | MEMF_CLEAR);
 421                             if (DO(icon)->do_ToolTypes)
 422                             {
 423                                 D(bug("[Icon.PNG] Allocated array of %u entries @ 0x%p (old 0x%p)\n", ttarraysize, DO(icon)->do_ToolTypes, old_tooltypes));
 424                                 if (old_tooltypes)
 425                                 {
 426                                     CopyMemQuick(old_tooltypes, DO(icon)->do_ToolTypes, (ttnum - 1) * sizeof(APTR));
 427
 428                                     /* TODO: Free old array */
 429                                 }
 430                             }
 431                             else
 432                             {
 433                                 ok = FALSE;
 434                             }
 435                         }
 436
 437                         if (!ok) break;
 438
 439                         DO(icon)->do_ToolTypes[ttnum - 1] = AllocMemIcon(DO(icon), strlen((char *)val) + 1, MEMF_PUBLIC | MEMF_CLEAR);
 440                         if (DO(icon)->do_ToolTypes[ttnum - 1])
 441                         {
 442                             strcpy(DO(icon)->do_ToolTypes[ttnum - 1], (char *)val);
 443                         }
 444                         else
 445                         {
 446                             ok = FALSE;
 447                         }
 448                         break;
 449
 450                 } /* switch(attr) */
 451
 452                 if (!ok) break;
 453
 454             } /* while(chunksize >= 4) */
 455
 456             if (!ok)
 457             {
 458                 D(bug("=== Failure during icOn chunk parsing ===\n"));
 459                 FreeIconPNG(&icon->ni_DiskObject, IconBase);
 460                 return FALSE;
 461             }
 462
 463
 464         } /* if (chunkpointer[0]) */
 465
 466         #undef DO
 467
 468         /*
 469          * FIXME: Someone killed PNG Icon do_Type detection here which causes
 470          *        following lines to always free DrawerData even when it
 471          *        shouldn't be freed (only possible to know if do_Type is
 472          *        known). So for now following lines disabled and DrawerData
 473          *        is always kept (even when it shouldn't).
 474          */
 475
 476 #if 0
 477         if (icon->ni_DiskObject.do_DrawerData &&
 478             (icon->ni_DiskObject.do_Type != WBDISK) &&
 479             (icon->ni_DiskObject.do_Type != WBDRAWER) &&
 480             (icon->ni_DiskObject.do_Type != WBGARBAGE))
 481         {
 482             FreePooled(pool, icon->ni_DiskObject.do_DrawerData, sizeof(struct DrawerData));
 483             icon->ni_DiskObject.do_DrawerData = NULL;
 484         }
 485 #endif
 486
 487     } /**/
 488
 489     /* Look for a possible 2nd PNG image attached onto the first one */
 490     {
 491         UBYTE *filepos = icon->ni_Extra.Data + icon->ni_Extra.PNG[0].Offset + 8;
 492         BOOL done = FALSE;
 493
 494         while(!done && filepos < ((UBYTE *)icon->ni_Extra.Data + icon->ni_Extra.Size))
 495         {
 496             ULONG chunksize = (filepos[0] << 24) | (filepos[1] << 16) |
 497                               (filepos[2] << 8) | filepos[3];
 498             ULONG chunktype = (filepos[4] << 24) | (filepos[5] << 16) |
 499                               (filepos[6] << 8) | filepos[7];
 500
 501             chunksize += 12;
 502
 503             if (chunktype == MAKE_ID('I', 'E', 'N', 'D'))
 504             {
 505                 done = TRUE;
 506             }
 507
 508             filepos += chunksize;
 509         }
 510
 511         if (filepos + 8 < (UBYTE *)icon->ni_Extra.Data + icon->ni_Extra.Size)
 512         {
 513             ULONG offset = filepos - (UBYTE *)icon->ni_Extra.Data;
 514
 515             icon->ni_Extra.PNG[0].Size = offset;
 516             icon->ni_Extra.PNG[1].Offset = offset;
 517             icon->ni_Extra.PNG[1].Size = (filesize - icon->ni_Extra.PNG[0].Size);
 518             icon->ni_Image[1].ARGB = ReadMemPNG(&icon->ni_DiskObject, filepos, &icon->ni_Face.Width, &icon->ni_Face.Height, NULL, NULL, IconBase);
 519         }
 520
 521     } /**/
 522
 523     /* If there's no image for selected-state, generate one */
 524     if (!icon->ni_Image[1].ARGB)
 525     {
 526         ULONG size = icon->ni_Face.Width * icon->ni_Face.Height;
 527
 528         if ((icon->ni_Image[1].ARGB = AllocMemIcon(&icon->ni_DiskObject, size * sizeof(ULONG), MEMF_PUBLIC)))
 529         {
 530             ULONG *src = (ULONG *)icon->ni_Image[0].ARGB;
 531             ULONG *dst = (ULONG *)icon->ni_Image[1].ARGB;
 532
 533             while(size--)
 534             {
 535                 ULONG pixel = *src++;
 536
 537                 /* Effects like in changetoselectediconcolor.c */
 538
 539         #if EFFECT == EFFECT_LIGHTEN
 540             #if AROS_BIG_ENDIAN
 541                 pixel = (pixel & 0xFF000000) +
 542                         ((pixel >> 1) & 0x007F7F7F) +
 543                         0x00808080;
 544             #else
 545                 pixel = (pixel & 0x000000FF) +
 546                         ((pixel >> 1) & 0x7F7F7F00) +
 547                         0x80808000;
 548             #endif
 549         #elif EFFECT == EFFECT_TINT_BLUE
 550             #if AROS_BIG_ENDIAN
 551                 pixel = (pixel & 0xFF000000) +
 552                         ((pixel >> 1) & 0x007F7F7F) +
 553                         0x00000080;
 554             #else
 555                 pixel = (pixel & 0x000000FF) +
 556                         ((pixel >> 1) & 0x7F7F7F00) +
 557                         0x80000000;
 558             #endif
 559
 560         #elif EFFECT == EFFECT_XOR
 561             #if AROS_BIG_ENDIAN
 562                 pixel = (pixel & 0xFF000000) +
 563                         ((pixel & 0x00FFFFFF) ^ 0x00FFFFFF);
 564             #else
 565                 pixel = (pixel & 0x000000FF) +
 566                         ((pixel & 0xFFFFFF00) ^ 0xFFFFFF00);
 567             #endif
 568         #endif
 569                 *dst++ = pixel;
 570             }
 571         }
 572     }
 573
 574     return TRUE;
 575
 576 }
 577
 578 /****************************************************************************************/
 579
 580 STATIC VOID MakeCRCTable(struct IconBase *IconBase)
 581 {
 582     unsigned long c;
 583     int n, k;
 584
 585     IconBase->ib_CRCTable = AllocMem(256 * sizeof(ULONG), MEMF_ANY);
 586     if (!IconBase->ib_CRCTable)
 587         return;
 588     for (n = 0; n < 256; n++)
 589     {
 590         c = (unsigned long) n;
 591         for (k = 0; k < 8; k++)
 592         {
 593             if (c & 1)
 594                 c = 0xedb88320L ^ (c >> 1);
 595             else
 596                 c = c >> 1;
 597         }
 598         IconBase->ib_CRCTable[n] = c;
 599     }
 600 }
 601
 602 /****************************************************************************************/
 603
 604 STATIC ULONG UpdateCRC(ULONG crc, UBYTE *buf, ULONG len, struct IconBase *IconBase)
 605 {
 606     ULONG c = crc;
 607     ULONG n;
 608
 609     for (n = 0; n < len; n++)
 610     {
 611         c = IconBase->ib_CRCTable[(c ^ buf[n]) & 0xff] ^ (c >> 8);
 612     }
 613
 614     return c;
 615
 616 }
 617
 618 /****************************************************************************************/
 619
 620 STATIC BOOL WriteIconAttr(BPTR file, ULONG id, ULONG val, ULONG *chunksize,
 621                           ULONG *crc, struct IconBase *IconBase)
 622 {
 623     UBYTE buf[8];
 624
 625     buf[0] = id >> 24;
 626     buf[1] = id >> 16;
 627     buf[2] = id >> 8;
 628     buf[3] = id;
 629     buf[4] = val >> 24;
 630     buf[5] = val >> 16;
 631     buf[6] = val >> 8;
 632     buf[7] = val;
 633
 634     if (Write(file, buf, 8) != 8) return FALSE;
 635
 636     *chunksize += 8;
 637     *crc = UpdateCRC(*crc, buf, 8, IconBase);
 638     return TRUE;
 639 }
 640
 641 /****************************************************************************************/
 642
 643 STATIC BOOL WriteIconStrAttr(BPTR file, ULONG id, char *val, ULONG *chunksize,
 644                              ULONG *crc, struct IconBase *IconBase)
 645 {
 646     UBYTE buf[4];
 647     ULONG len = strlen(val) + 1;
 648
 649     buf[0] = id >> 24;
 650     buf[1] = id >> 16;
 651     buf[2] = id >> 8;
 652     buf[3] = id;
 653
 654     if (Write(file, buf, 4) != 4) return FALSE;
 655     *crc = UpdateCRC(*crc, buf, 4, IconBase);
 656
 657     if (Write(file, val, len) != len) return FALSE;
 658     *crc = UpdateCRC(*crc, val, len, IconBase);
 659
 660     *chunksize += 4 + len;
 661
 662     return TRUE;
 663 }
 664
 665 /****************************************************************************************/
 666
 667 STATIC BOOL WriteIconChunk(BPTR file, struct DiskObject *dobj, struct IconBase *IconBase)
 668 {
 669     ULONG crc = 0xFFFFFFFF;
 670     ULONG chunksize = 0;
 671     ULONG sizeseek = Seek(file, 0, OFFSET_CURRENT);
 672     UBYTE buf[] = {0x12, 0x34, 0x56, 0x78, 'i', 'c', 'O', 'n'};
 673
 674     if (sizeseek < 0) return FALSE;
 675
 676     /* Write Chunk size + chunk type */
 677     if (Write(file, buf, 8) != 8) return FALSE;
 678
 679     crc = UpdateCRC(crc, buf + 4, 4, IconBase); /* chunksize is excluded from CRC */
 680
 681     /* Write Frameless */
 682     if (!WriteIconAttr(file, ATTR_FRAMELESS, NATIVEICON(dobj)->ni_Frameless, &chunksize, &crc, IconBase))
 683     {
 684         return FALSE;
 685     }
 686
 687     /* Write Stack Size */
 688
 689     if (!WriteIconAttr(file, ATTR_STACKSIZE, dobj->do_StackSize, &chunksize, &crc, IconBase))
 690     {
 691         return FALSE;
 692     }
 693
 694     /* Write Icon X Position */
 695     if (dobj->do_CurrentX != NO_ICON_POSITION)
 696     {
 697         if (!WriteIconAttr(file, ATTR_ICONX, dobj->do_CurrentX, &chunksize, &crc, IconBase))
 698         {
 699             return FALSE;
 700         }
 701     }
 702
 703     /* Write Icon Y Position */
 704     if (dobj->do_CurrentY != NO_ICON_POSITION)
 705     {
 706         if (!WriteIconAttr(file, ATTR_ICONY, dobj->do_CurrentY, &chunksize, &crc, IconBase))
 707         {
 708             return FALSE;
 709         }
 710     }
 711
 712     if (dobj->do_DrawerData)
 713     {
 714         if (!WriteIconAttr(file, ATTR_DRAWERX, dobj->do_DrawerData->dd_NewWindow.LeftEdge,
 715             &chunksize, &crc, IconBase))
 716         {
 717             return FALSE;
 718         }
 719
 720         if (!WriteIconAttr(file, ATTR_DRAWERY, dobj->do_DrawerData->dd_NewWindow.TopEdge,
 721             &chunksize, &crc, IconBase))
 722         {
 723             return FALSE;
 724         }
 725
 726         if (!WriteIconAttr(file, ATTR_DRAWERWIDTH, dobj->do_DrawerData->dd_NewWindow.Width,
 727             &chunksize, &crc, IconBase))
 728         {
 729             return FALSE;
 730         }
 731
 732         if (!WriteIconAttr(file, ATTR_DRAWERHEIGHT, dobj->do_DrawerData->dd_NewWindow.Height,
 733             &chunksize, &crc, IconBase))
 734         {
 735             return FALSE;
 736         }
 737
 738         if (!WriteIconAttr(file, ATTR_DRAWERFLAGS, dd_to_flags(dobj),
 739             &chunksize, &crc, IconBase))
 740         {
 741             return FALSE;
 742         }
 743
 744     } /* if (dobj->do_DrawerData) */
 745
 746     if (dobj->do_DefaultTool)
 747     {
 748         if (!WriteIconStrAttr(file, ATTR_DEFAULTTOOL, dobj->do_DefaultTool,
 749             &chunksize, &crc, IconBase))
 750         {
 751             return FALSE;
 752         }
 753
 754     }
 755
 756     if (dobj->do_ToolTypes)
 757     {
 758         STRPTR *tt = (STRPTR *)dobj->do_ToolTypes;
 759
 760         for(tt = (STRPTR *)dobj->do_ToolTypes; *tt; tt++)
 761         {
 762             if (!WriteIconStrAttr(file, ATTR_TOOLTYPE, *tt, &chunksize,
 763                                   &crc, IconBase))
 764             {
 765                 return FALSE;
 766             }
 767         }
 768     }
 769
 770     /* Write CRC */
 771
 772     crc ^= 0xFFFFFFFF;
 773     buf[0] = crc >> 24;
 774     buf[1] = crc >> 16;
 775     buf[2] = crc >> 8;
 776     buf[3] = crc;
 777     if (Write(file, buf, 4) != 4) return FALSE;
 778
 779     /* Write chunk's size */
 780     if (Seek(file, sizeseek, OFFSET_BEGINNING) < 0) return FALSE;
 781
 782     buf[0] = chunksize >> 24;
 783     buf[1] = chunksize >> 16;
 784     buf[2] = chunksize >> 8;
 785     buf[3] = chunksize;
 786     if (Write(file, buf, 4) != 4) return FALSE;
 787
 788     if (Seek(file, 0, OFFSET_END) < 0) return FALSE;
 789
 790     return TRUE;
 791 }
 792
 793 /****************************************************************************************/
 794
 795 BOOL WriteIconPNG(BPTR file, struct DiskObject *dobj, struct IconBase *IconBase)
 796 {
 797     struct NativeIcon   *nativeicon = NATIVEICON(dobj);
 798     UBYTE               *mempos = nativeicon->ni_Extra.Data + nativeicon->ni_Extra.PNG[0].Offset;
 799     BOOL                 done = FALSE;
 800
 801     D(bug("%s: ni=%p, ni->ni_Extra.Data = %p\n", __func__, nativeicon, nativeicon->ni_Extra.Data));
 802     if (nativeicon->ni_Extra.Data == NULL)
 803         return FALSE;
 804
 805     ObtainSemaphore(&IconBase->iconlistlock);
 806     if (!IconBase->ib_CRCTable)
 807         MakeCRCTable(IconBase);
 808     ReleaseSemaphore(&IconBase->iconlistlock);
 809     if (!IconBase->ib_CRCTable)
 810         return FALSE;
 811
 812     /* Write PNG header */
 813     if (Write(file, mempos, 8) != 8) return FALSE;
 814
 815     mempos += 8;
 816
 817     while(!done)
 818     {
 819         ULONG chunksize = (mempos[0] << 24) | (mempos[1] << 16) |
 820                           (mempos[2] << 8) | mempos[3];
 821         ULONG chunktype = (mempos[4] << 24) | (mempos[5] << 16) |
 822                           (mempos[6] << 8) | mempos[7];
 823
 824         chunksize += 12;
 825
 826         if (chunktype == MAKE_ID('I', 'E', 'N', 'D'))
 827         {
 828             if (!WriteIconChunk(file, dobj, IconBase)) return FALSE;
 829             done = TRUE;
 830         }
 831
 832         if (chunktype != MAKE_ID('i', 'c', 'O', 'n'))
 833         {
 834             if (Write(file, mempos, chunksize) != chunksize)
 835             {
 836                 return FALSE;
 837             }
 838         }
 839
 840         mempos += chunksize;
 841
 842     }
 843
 844     if (nativeicon->ni_Extra.PNG[1].Offset > 0)
 845     {
 846         ULONG size = nativeicon->ni_Extra.PNG[1].Size;
 847
 848         /* 2nd PNG Image attached */
 849
 850         if (Write(file, nativeicon->ni_Extra.Data + nativeicon->ni_Extra.PNG[1].Offset, size) != size) return FALSE;
 851     }
 852
 853     return TRUE;
 854 }
 855
 856 /****************************************************************************************/
 857
 858 VOID FreeIconPNG(struct DiskObject *dobj, struct IconBase *IconBase)
 859 {
 860 }
 861
 862 /****************************************************************************************/