workbench/libs/icon/diskobj35io.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /****************************************************************************************/
   7
   8 #include <datatypes/pictureclass.h>
   9
  10 #include <proto/dos.h>
  11 #include <proto/alib.h>
  12
  13 #include <aros/bigendianio.h>
  14 #include <aros/asmcall.h>
  15
  16 #include "icon_intern.h"
  17
  18 #   define DEBUG 0
  19 #   include <aros/debug.h>
  20
  21 /****************************************************************************************/
  22
  23 #define ID_ICON MAKE_ID('I','C','O','N')
  24 #define ID_FACE MAKE_ID('F','A','C','E')
  25 #define ID_IMAG MAKE_ID('I','M','A','G')
  26
  27 /****************************************************************************************/
  28
  29 struct FileFaceChunk
  30 {
  31     UBYTE Width;
  32     UBYTE Height;
  33     UBYTE Flags;
  34     UBYTE Aspect;
  35     UBYTE MaxPaletteBytes[2];
  36 };
  37
  38 struct FileImageChunk
  39 {
  40     UBYTE TransparentColor;
  41     UBYTE NumColors;
  42     UBYTE Flags;
  43     UBYTE ImageFormat;
  44     UBYTE PaletteFormat;
  45     UBYTE Depth;
  46     UBYTE NumImageBytes[2];
  47     UBYTE NumPaletteBytes[2];
  48 };
  49
  50 /****************************************************************************************/
  51
  52 #if 1
  53 LONG MyDOSStreamHandler(struct Hook *hook, struct IFFHandle * iff, struct IFFStreamCmd * cmd)
  54 {
  55     LONG error = 0;
  56
  57     switch(cmd->sc_Command)
  58     {
  59         case IFFCMD_INIT:
  60         case IFFCMD_CLEANUP:
  61             error = 0;
  62             break;
  63
  64         case IFFCMD_READ:
  65             error = (FRead((BPTR)iff->iff_Stream, cmd->sc_Buf, 1, cmd->sc_NBytes)) != cmd->sc_NBytes;
  66             break;
  67
  68         case IFFCMD_WRITE:
  69             error = (FWrite((BPTR)iff->iff_Stream, cmd->sc_Buf, 1, cmd->sc_NBytes)) != cmd->sc_NBytes;
  70             break;
  71
  72         case IFFCMD_SEEK:
  73             Flush((BPTR)iff->iff_Stream);
  74             error = (Seek((BPTR)iff->iff_Stream, cmd->sc_NBytes, OFFSET_CURRENT)) == -1;
  75             break;
  76     }
  77
  78     return error;
  79 }
  80 #endif
  81
  82 /****************************************************************************************/
  83
  84 /* Decode35() based on ModifyIcon by Dirk Stöcker */
  85
  86 /****************************************************************************************/
  87
  88 static char *Decode35(UBYTE *buffer, UBYTE *outbuffer, LONG numbytes, LONG bits, LONG entries)
  89 {
  90     int cop = 0, loop = 0, numbits = 0, mask, curentry = 0;
  91     ULONG bitbuf = 0;
  92     UBYTE byte;
  93
  94     mask = (1<<bits)-1;
  95
  96     while((numbytes || (cop && numbits >= bits)) && (curentry < entries))
  97     {
  98         if(!cop)
  99         {
 100             if(numbits < 8)
 101             {
 102                 bitbuf = (bitbuf<<8)|*(buffer++); --numbytes;
 103                 numbits += 8;
 104             }
 105
 106             byte = (bitbuf>>(numbits-8))&0xFF;
 107             numbits -= 8;
 108
 109             if(byte <= 127)     cop = byte+1;
 110             else if(byte > 128) loop = 256-byte+1;
 111             else                continue;
 112         }
 113
 114         if(cop) ++loop;
 115
 116         if(numbits < bits)
 117         {
 118             bitbuf = (bitbuf<<8)|*(buffer++); --numbytes;
 119             numbits += 8;
 120         }
 121
 122         byte = (bitbuf>>(numbits-bits))&mask;
 123
 124         while(loop && (curentry < entries))
 125         {
 126             *outbuffer++ = byte;
 127             ++curentry;
 128             --loop;
 129         }
 130
 131         if(cop) --cop;
 132
 133         numbits -= bits;
 134     }
 135
 136     return curentry != entries ? "error decoding new icon data" : 0;
 137 }
 138
 139 /****************************************************************************************/
 140
 141 VOID MakeMask35(UBYTE *imgdata, UBYTE *imgmask, UBYTE transpcolor, LONG imagew, LONG imageh)
 142 {
 143     UBYTE *src, *dst;
 144     WORD x, y, bpr, mask;
 145
 146     memset(imgmask, 0xFF, RASSIZE(imagew, imageh));
 147
 148     bpr = ((imagew + 15) & ~15) / 8;
 149     src = imgdata;
 150     dst = imgmask;
 151
 152     for(y = 0; y < imageh; y++)
 153     {
 154         UBYTE *dstx = dst;
 155
 156         mask = 0x80;
 157
 158         for(x = 0; x < imagew; x++)
 159         {
 160             if (*src++ == transpcolor)
 161             {
 162                 *dstx &= ~mask;
 163             }
 164
 165             mask >>= 1;
 166             if (!mask)
 167             {
 168                 mask = 0x80;
 169                 dstx++;
 170             }
 171         }
 172         dst += bpr;
 173
 174     }
 175
 176 }
 177
 178 /****************************************************************************************/
 179
 180 STATIC BOOL ReadImage35(struct IFFHandle *iff, struct FileFaceChunk *fc,
 181                         struct FileImageChunk *ic, UBYTE **imgdataptr,
 182                         UBYTE **imgpalptr, UBYTE **imgmaskptr, struct IconBase *IconBase)
 183 {
 184     UBYTE *src, *mem, *imgdata, *imgpal = NULL, *imgmask = NULL;
 185     LONG size, imgsize, palsize, imagew, imageh, numcols;
 186
 187     imagew = fc->Width + 1;
 188     imageh = fc->Height + 1;
 189     numcols = ic->NumColors + 1;
 190
 191     imgsize = ic->NumImageBytes[0] * 256 + ic->NumImageBytes[1] + 1;
 192     if (ic->Flags & IMAGE35F_HASPALETTE)
 193     {
 194         palsize = ic->NumPaletteBytes[0] * 256 + ic->NumPaletteBytes[1] + 1;
 195     }
 196     else
 197     {
 198         palsize = 0;
 199     }
 200
 201     size = imgsize + palsize;
 202
 203     src = mem = AllocVec(size, MEMF_ANY);
 204     if (!src) return FALSE;
 205
 206     if (ReadChunkBytes(iff, src, size) != size)
 207     {
 208         FreeVec(src);
 209         return FALSE;
 210     }
 211
 212     size = imagew * imageh;
 213
 214     if (ic->Flags & IMAGE35F_HASPALETTE)
 215     {
 216         size += numcols * sizeof(struct ColorRegister);
 217     }
 218
 219     if (ic->Flags & IMAGE35F_HASTRANSPARENTCOLOR)
 220     {
 221         size += RASSIZE(imagew, imageh);
 222     }
 223
 224     imgdata = AllocVec(size, MEMF_ANY);
 225     if (!imgdata)
 226     {
 227         FreeVec(src);
 228         return FALSE;
 229     }
 230
 231     if (ic->ImageFormat == 0)
 232     {
 233         memcpy(imgdata, src, imagew * imageh);
 234     }
 235     else
 236     {
 237         Decode35(src, imgdata, imgsize, ic->Depth, imagew * imageh);
 238     }
 239
 240     if (ic->Flags & IMAGE35F_HASPALETTE)
 241     {
 242         struct ColorRegister *dst;
 243
 244         src += imgsize;
 245
 246         imgpal = imgdata + imagew * imageh;
 247
 248         dst = (struct ColorRegister *)imgpal;
 249
 250         if (ic->PaletteFormat == 0)
 251         {
 252             ULONG i, r, g, b;
 253
 254             for(i = 0; i < numcols; i++)
 255             {
 256                 r = *src++;
 257                 g = *src++;
 258                 b = *src++;
 259
 260                 dst->red   = r;
 261                 dst->green = g;
 262                 dst->blue  = b;
 263                 dst++;
 264             }
 265         }
 266         else
 267         {
 268             Decode35(src, imgpal, palsize, 8, 3 * numcols);
 269
 270             if (sizeof(struct ColorRegister) != 3)
 271             {
 272                 struct ColorRegister    *dst;
 273                 UWORD                    i, r, g, b;
 274
 275                 src = imgpal + 3 * numcols;
 276                 dst = (struct ColorRegister *)(imgpal + sizeof(struct ColorRegister) * numcols);
 277
 278                 for (i = 0; i < numcols; i++)
 279                 {
 280                     b = *--src;
 281                     g = *--src;
 282                     r = *--src;
 283
 284                     dst--;
 285
 286                     dst->red = r;
 287                     dst->green = g;
 288                     dst->blue = b;
 289                 }
 290             }
 291         }
 292
 293     } /* if (ic->Flags & IMAGE35F_HASPALETTE) */
 294
 295     if (ic->Flags & IMAGE35F_HASTRANSPARENTCOLOR)
 296     {
 297         imgmask = imgdata + imagew * imageh;
 298         if (ic->Flags & IMAGE35F_HASPALETTE)
 299         {
 300             imgmask += numcols * sizeof(struct ColorRegister);
 301         }
 302
 303         MakeMask35(imgdata, imgmask,ic->TransparentColor, imagew, imageh);
 304     }
 305
 306     *imgdataptr = imgdata;
 307     *imgpalptr  = imgpal;
 308     *imgmaskptr = imgmask;
 309
 310     FreeVec(mem);
 311
 312     return TRUE;
 313 }
 314
 315 /****************************************************************************************/
 316
 317 BOOL ReadIcon35(struct NativeIcon *icon, struct Hook *streamhook,
 318                 void *stream, struct IconBase *IconBase)
 319 {
 320     static LONG stopchunks[] =
 321     {
 322         ID_ICON, ID_FACE,
 323         ID_ICON, ID_IMAG
 324     };
 325
 326     struct IFFHandle        *iff;
 327     struct Hook              iffhook;
 328     struct FileFaceChunk     fc;
 329     struct FileImageChunk    ic1, ic2;
 330     UBYTE                   *img1data = NULL, *img2data = NULL,
 331                             *img1pal = NULL, *img2pal = NULL,
 332                             *img1mask = NULL, *img2mask = NULL;
 333     BOOL  have_face = FALSE, have_imag1 = FALSE, have_imag2 = FALSE;
 334
 335     D(bug("ReadIcon35\n"));
 336
 337     iffhook.h_Entry    = (HOOKFUNC)HookEntry;
 338     iffhook.h_SubEntry = (HOOKFUNC)MyDOSStreamHandler;
 339
 340     if ((iff = AllocIFF()))
 341     {
 342         D(bug("ReadIcon35. AllocIFF okay\n"));
 343
 344         iff->iff_Stream = (IPTR)stream;
 345
 346         InitIFF(iff, IFFF_RSEEK, &iffhook);
 347
 348         if (!OpenIFF(iff, IFFF_READ))
 349         {
 350             D(bug("ReadIcon35. OpenIFF okay\n"));
 351
 352             if (!StopChunks(iff, stopchunks, 2))
 353             {
 354                 LONG error;
 355
 356                 D(bug("ReadIcon35. StopChunks okay\n"));
 357
 358                 while(!(error = ParseIFF(iff, IFFPARSE_SCAN)))
 359                 {
 360                     struct ContextNode *cn;
 361
 362                     cn = CurrentChunk(iff);
 363
 364                     D(bug("inside ParseIFF loop\n"));
 365                     if ((cn->cn_ID == ID_FACE) && (cn->cn_Size >= sizeof(struct FileFaceChunk)))
 366                     {
 367                         D(bug("ReadIcon35. Found FACE chunk\n"));
 368                         if (ReadChunkBytes(iff, &fc, sizeof(fc)) == sizeof(fc))
 369                         {
 370                             have_face = TRUE;
 371                         }
 372                     }
 373                     else if (have_face && (cn->cn_ID == ID_IMAG) && (cn->cn_Size >= sizeof(struct FileImageChunk)))
 374                     {
 375                         D(bug("ReadIcon35. Found IMAG chunk\n"));
 376                         if (ReadChunkBytes(iff, (have_imag1 ? &ic2 : &ic1), sizeof(ic1)) == sizeof(ic1))
 377                         {
 378                             if (have_imag1)
 379                             {
 380                                 if (ReadImage35(iff, &fc, &ic2, &img2data, &img2pal, &img2mask, IconBase))
 381                                 {
 382                                     have_imag2 = TRUE;
 383                                 }
 384                             }
 385                             else
 386                             {
 387                                 if (ReadImage35(iff, &fc, &ic1, &img1data, &img1pal, &img1mask, IconBase))
 388                                 {
 389                                     have_imag1 = TRUE;
 390                                 }
 391                             }
 392
 393                         }
 394
 395                     }
 396
 397
 398                 } /* while(!ParseIFF(iff, IFFPARSE_SCAN)) */
 399
 400             } /* if (!StopChunks(iff, stopchunks, 2)) */
 401
 402         } /* if (!OpenIFF(iff, IFFF_READ)) */
 403
 404         FreeIFF(iff);
 405
 406     } /* if ((iff = AllocIFF())) */
 407
 408     if (have_imag1)
 409     {
 410         icon->icon35.width  = fc.Width + 1;
 411         icon->icon35.height = fc.Height + 1;
 412         icon->icon35.flags  = fc.Flags;
 413         icon->icon35.aspect = fc.Aspect;
 414
 415         icon->icon35.img1.imagedata         = img1data;
 416         icon->icon35.img1.palette           = img1pal;
 417         icon->icon35.img1.mask              = img1mask;
 418         icon->icon35.img1.numcolors         = ic1.NumColors + 1;
 419         icon->icon35.img1.depth             = ic1.Depth;
 420         icon->icon35.img1.flags             = ic1.Flags;
 421         icon->icon35.img1.transparentcolor  = ic1.TransparentColor;
 422
 423         if (have_imag2)
 424         {
 425             icon->icon35.img2.imagedata         = img2data;
 426             icon->icon35.img2.mask              = img2mask;
 427             icon->icon35.img2.depth             = ic2.Depth;
 428             icon->icon35.img2.flags             = ic2.Flags;
 429             icon->icon35.img2.transparentcolor  = ic2.TransparentColor;
 430
 431             if (img2pal)
 432             {
 433                 icon->icon35.img2.palette   = img2pal;
 434                 icon->icon35.img2.numcolors = ic2.NumColors + 1;
 435             }
 436             else
 437             {
 438                 icon->icon35.img2.palette   = icon->icon35.img1.palette;
 439                 icon->icon35.img2.numcolors = icon->icon35.img1.numcolors;
 440             }
 441         }
 442     }
 443
 444     return TRUE;
 445 }
 446
 447 /****************************************************************************************/
 448
 449 /* Encode35() based on ModifyIcon source by Dirk Stöcker */
 450
 451 /****************************************************************************************/
 452
 453 static UBYTE *Encode35(ULONG depth, UBYTE *dtype, LONG *dsize, ULONG size, UBYTE *src)
 454 {
 455     int   i, j, k;
 456     ULONG bitbuf, numbits;
 457     UBYTE *buf;
 458     LONG  ressize, numcopy, numequal;
 459
 460     buf = AllocVec(size * 2, MEMF_ANY);
 461     if (!buf) return NULL;
 462
 463     numcopy = 0;
 464     numequal = 1;
 465     bitbuf = 0;
 466     numbits = 0;
 467     ressize = 0;
 468     k = 0; /* the really output pointer */
 469
 470     for(i = 1; numequal || numcopy;)
 471     {
 472         if(i < size && numequal && (src[i-1] == src[i]))
 473         {
 474             ++numequal; ++i;
 475         }
 476         else if(i < size && numequal*depth <= 16)
 477         {
 478             numcopy += numequal; numequal = 1; ++i;
 479         }
 480         else
 481         {
 482             /* care for end case, where it maybe better to join the two */
 483             if(i == size && numcopy + numequal <= 128 && (numequal-1)*depth <= 8)
 484             {
 485                 numcopy += numequal; numequal = 0;
 486             }
 487
 488             if(numcopy)
 489             {
 490                 if((j = numcopy) > 128) j = 128;
 491
 492                 bitbuf = (bitbuf<<8) | (j-1);
 493                 numcopy -= j;
 494             }
 495             else
 496             {
 497                 if((j = numequal) > 128) j = 128;
 498
 499                 bitbuf = (bitbuf<<8) | (256-(j-1));
 500                 numequal -= j;
 501                 k += j-1;
 502                 j = 1;
 503             }
 504
 505             buf[ressize++] = (bitbuf >> numbits);
 506
 507             while(j--)
 508             {
 509                 numbits += depth;
 510                 bitbuf = (bitbuf<<depth) | src[k++];
 511
 512                 if(numbits >= 8)
 513                 {
 514                     numbits -= 8;
 515                     buf[ressize++] = (bitbuf >> numbits);
 516                 }
 517             }
 518
 519             if(i < size && !numcopy && !numequal)
 520             {
 521                 numequal = 1; ++i;
 522             }
 523         }
 524     }
 525
 526     if(numbits)
 527         buf[ressize++] = bitbuf << (8-numbits);
 528
 529     if(ressize > size) /* no RLE */
 530     {
 531         ressize = size;
 532         *dtype = 0;
 533         for(i = 0; i < size; ++i)
 534             buf[i]= src[i];
 535     }
 536     else
 537         *dtype = 1;
 538
 539     *dsize = ressize;
 540
 541     return buf;
 542 }
 543
 544 /****************************************************************************************/
 545
 546 static BOOL WriteImage35(struct IFFHandle *iff, struct Icon35 *icon35,
 547                          struct Image35 *img, struct IconBase *IconBase)
 548 {
 549     struct FileImageChunk   ic;
 550     UBYTE                   *imagedata, *pal = NULL;
 551     LONG                    imagesize, palsize = 0;
 552     UBYTE                   imagepacked, palpacked = 0;
 553     UBYTE                   imageflags;
 554     BOOL                    ok = FALSE;
 555
 556     imageflags = img->flags;
 557
 558     if (img->palette && (img->flags & IMAGE35F_HASPALETTE))
 559     {
 560         pal = Encode35(8, &palpacked, &palsize, img->numcolors * 3, img->palette);
 561         if (!pal) return FALSE;
 562     }
 563     else
 564     {
 565         imageflags &= ~IMAGE35F_HASPALETTE;
 566     }
 567
 568     imagedata = Encode35(img->depth, &imagepacked, &imagesize,
 569                          icon35->width * icon35->height, img->imagedata);
 570
 571     if (!imagedata)
 572     {
 573         if (pal) FreeVec(pal);
 574         return FALSE;
 575     }
 576
 577     ic.TransparentColor     = img->transparentcolor;
 578     ic.NumColors            = img->numcolors - 1;
 579     ic.Flags                = imageflags;
 580     ic.ImageFormat          = imagepacked;
 581     ic.PaletteFormat        = palpacked;
 582     ic.Depth                = img->depth;
 583     ic.NumImageBytes[0]     = (imagesize - 1) / 256;
 584     ic.NumImageBytes[1]     = (imagesize - 1) & 255;
 585     ic.NumPaletteBytes[0]   = (palsize - 1) / 256;
 586     ic.NumPaletteBytes[1]   = (palsize - 1) & 255;
 587
 588     if (!PushChunk(iff, ID_ICON, ID_IMAG, IFFSIZE_UNKNOWN))
 589     {
 590         ok = TRUE;
 591
 592         if (WriteChunkBytes(iff, &ic, sizeof(ic)) != sizeof(ic))
 593         {
 594             ok = FALSE;
 595         }
 596
 597         if (ok)
 598         {
 599             if (WriteChunkBytes(iff, imagedata, imagesize) != imagesize)
 600             {
 601                 ok = FALSE;
 602             }
 603         }
 604
 605         if (ok && pal)
 606         {
 607             if (WriteChunkBytes(iff, pal, palsize) != palsize)
 608             {
 609                 ok = FALSE;
 610             }
 611         }
 612
 613
 614         PopChunk(iff);
 615
 616     } /* if (!PushChunk(iff, ID_ICON, ID_IMAG, IFFSIZE_UNKNOWN)) */
 617
 618     FreeVec(imagedata);
 619     if (pal) FreeVec(pal);
 620
 621     return ok;
 622 }
 623
 624 /****************************************************************************************/
 625
 626 BOOL WriteIcon35(struct NativeIcon *icon, struct Hook *streamhook,
 627                  void *stream, struct IconBase *IconBase)
 628 {
 629     struct IFFHandle        *iff;
 630     struct Hook              iffhook;
 631     struct FileFaceChunk     fc;
 632     BOOL                     ok = FALSE;
 633
 634     D(bug("WriteIcon35\n"));
 635
 636     if (!GetNativeIcon(&icon->dobj, IconBase))
 637     {
 638         return TRUE;
 639     }
 640
 641     iffhook.h_Entry    = (HOOKFUNC)HookEntry;
 642     iffhook.h_SubEntry = (HOOKFUNC)MyDOSStreamHandler;
 643
 644     if ((iff = AllocIFF()))
 645     {
 646         D(bug("WriteIcon35. AllocIFF okay\n"));
 647
 648         iff->iff_Stream = (IPTR)stream;
 649
 650         InitIFF(iff, IFFF_RSEEK, &iffhook);
 651
 652         if (!OpenIFF(iff, IFFF_WRITE))
 653         {
 654             D(bug("WriteIcon35. OpenIFF okay\n"));
 655
 656             if (!PushChunk(iff, ID_ICON, ID_FORM, IFFSIZE_UNKNOWN))
 657             {
 658                 D(bug("WriteIcon35. PushChunk(ID_ICON, ID_FORM) okay\n"));
 659
 660                 if (!PushChunk(iff, ID_ICON, ID_FACE, sizeof(struct FileFaceChunk)))
 661                 {
 662                     WORD cmapentries;
 663
 664                     D(bug("WriteIcon35. PushChunk(ID_ICON, ID_FACE) okay\n"));
 665
 666                     fc.Width  = icon->icon35.width - 1;
 667                     fc.Height = icon->icon35.height - 1;
 668                     fc.Flags  = icon->icon35.flags;
 669                     fc.Aspect = icon->icon35.aspect;
 670
 671                     cmapentries = icon->icon35.img1.numcolors;
 672
 673                     if (icon->icon35.img2.imagedata &&
 674                         icon->icon35.img2.palette &&
 675                         (icon->icon35.img2.flags & IMAGE35F_HASPALETTE))
 676                     {
 677                         if (icon->icon35.img2.numcolors > cmapentries)
 678                         {
 679                             cmapentries = icon->icon35.img2.numcolors;
 680                         }
 681                     }
 682
 683                     cmapentries = cmapentries * 3 - 1;
 684
 685                     fc.MaxPaletteBytes[0] = cmapentries / 256;
 686                     fc.MaxPaletteBytes[1] = cmapentries & 255;
 687
 688                     if (WriteChunkBytes(iff, &fc, sizeof(fc)) == sizeof(fc))
 689                     {
 690                         D(bug("WriteIcon35. WriteChunkBytes of FACE chunk ok.\n"));
 691
 692                         PopChunk(iff);
 693
 694                         if (WriteImage35(iff, &icon->icon35, &icon->icon35.img1, IconBase))
 695                         {
 696                             D(bug("WriteIcon35. WriteImage35() of 1st image ok.\n"));
 697
 698                             if (icon->icon35.img2.imagedata)
 699                             {
 700                                 if (WriteImage35(iff, &icon->icon35, &icon->icon35.img2, IconBase))
 701                                 {
 702                                     D(bug("WriteIcon35. WriteImage35() of 2nd image ok.\n"));
 703
 704                                     ok = TRUE;
 705                                 }
 706
 707                             } /* if (icon->icon35.img2.imagedata) */
 708                             else
 709                             {
 710                                 ok = TRUE;
 711                             }
 712
 713                         } /* if (WriteImage35(iff, &icon->icon35, &icon->icon35.img1, IconBase)) */
 714
 715                     } /* if (WriteChunkBytes(iff, &fc, sizeof(fc)) == sizeof(fc)) */
 716                     else
 717                     {
 718                         PopChunk(iff);
 719                     }
 720
 721                 } /* if (!PushChunk(iff, ID_ICON, ID_FACE, sizeof(struct FileFaceChunk))) */
 722
 723                 PopChunk(iff);
 724
 725             } /* if (!PushChunk(iff, ID_ICON, ID_FORM, IFFSIZE_UNKNOWN)) */
 726
 727         } /* if (!OpenIFF(iff, IFFF_READ)) */
 728
 729     } /* if ((iff = AllocIFF())) */
 730
 731     return ok;
 732 }
 733
 734 /****************************************************************************************/
 735
 736 VOID FreeIcon35(struct NativeIcon *icon, struct IconBase *IconBase)
 737 {
 738     if (icon->icon35.img1.imagedata) FreeVec(icon->icon35.img1.imagedata);
 739     if (icon->icon35.img2.imagedata) FreeVec(icon->icon35.img2.imagedata);
 740
 741     icon->icon35.img1.imagedata = NULL;
 742     icon->icon35.img2.imagedata = NULL;
 743
 744     /* We don't free img.palette/img.mask because imagedata/palette/mask
 745        were allocated together in one AllocVec() call */
 746
 747 }
 748
 749 /****************************************************************************************/
 750