workbench/libs/icon/diskobjio.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Read an icon from an .info file
   6 */
   7
   8 #ifdef __MORPHOS__
   9 #undef __NOLIBBASE__
  10 #endif
  11
  12 /****************************************************************************************/
  13
  14 #include <stdio.h>
  15 #include <stddef.h>
  16 #include <string.h>
  17
  18 #include <exec/memory.h>
  19 #include <aros/bigendianio.h>
  20 #include <aros/asmcall.h>
  21 #include <aros/macros.h>
  22 #include <workbench/workbench.h>
  23
  24 #include <proto/alib.h>
  25 #include <proto/exec.h>
  26 #include <proto/dos.h>
  27 #include <proto/arossupport.h>
  28 #include <proto/intuition.h>
  29
  30 #include "icon_intern.h"
  31
  32 #   include <aros/debug.h>
  33
  34 /****************************************************************************************/
  35
  36 AROS_UFP3S(ULONG, ProcessCheckFileType,
  37     AROS_UFPA(struct Hook *,   hook, A0),
  38     AROS_UFPA(struct Hook *,   streamhook, A2),
  39     AROS_UFPA(struct SDData *, data, A1)
  40 );
  41
  42 AROS_UFP3S(ULONG, ProcessOldDrawerData,
  43     AROS_UFPA(struct Hook *,   hook, A0),
  44     AROS_UFPA(struct Hook *,   streamhook, A2),
  45     AROS_UFPA(struct SDData *, data, A1)
  46 );
  47
  48 AROS_UFP3S(ULONG, ProcessNewDrawerData,
  49     AROS_UFPA(struct Hook *,   hook, A0),
  50     AROS_UFPA(struct Hook *,   streamhook, A2),
  51     AROS_UFPA(struct SDData *, data, A1)
  52 );
  53
  54 AROS_UFP3S(ULONG, ProcessGadgetRender,
  55     AROS_UFPA(struct Hook *,   hook, A0),
  56     AROS_UFPA(struct Hook *,    streamhook, A2),
  57     AROS_UFPA(struct SDData *, data, A1)
  58 );
  59
  60 AROS_UFP3S(ULONG, ProcessSelectRender,
  61     AROS_UFPA(struct Hook *,   hook, A0),
  62     AROS_UFPA(struct Hook *,   streamhook, A2),
  63     AROS_UFPA(struct SDData *, data, A1)
  64 );
  65
  66 AROS_UFP3S(ULONG, ProcessDefaultTool,
  67     AROS_UFPA(struct Hook *,   hook, A0),
  68     AROS_UFPA(struct Hook *,   streamhook, A2),
  69     AROS_UFPA(struct SDData *, data, A1)
  70 );
  71
  72 AROS_UFP3S(ULONG, ProcessToolWindow,
  73     AROS_UFPA(struct Hook *,   hook, A0),
  74     AROS_UFPA(struct Hook *,   streamhook, A2),
  75     AROS_UFPA(struct SDData *, data, A1)
  76 );
  77
  78 AROS_UFP3S(ULONG, ProcessToolTypes,
  79     AROS_UFPA(struct Hook *,   hook, A0),
  80     AROS_UFPA(struct Hook *,   streamhook, A2),
  81     AROS_UFPA(struct SDData *, data, A1)
  82 );
  83
  84 AROS_UFP3S(ULONG, ProcessFlagPtr,
  85     AROS_UFPA(struct Hook *,   hook, A0),
  86     AROS_UFPA(struct Hook *,   streamhook, A2),
  87     AROS_UFPA(struct SDData *, data, A1)
  88 );
  89
  90 AROS_UFP3S(ULONG, ProcessIcon35,
  91     AROS_UFPA(struct Hook *,   hook, A0),
  92     AROS_UFPA(struct Hook *,   streamhook, A2),
  93     AROS_UFPA(struct SDData *, data, A1)
  94 );
  95
  96 AROS_UFP3S(ULONG, ProcessIconNI,
  97     AROS_UFPA(struct Hook *,   hook, A0),
  98     AROS_UFPA(struct Hook *,   streamhook, A2),
  99     AROS_UFPA(struct SDData *, data, A1)
 100 );
 101
 102 const struct Hook
 103 ProcessCheckFileTypeHook =
 104 {
 105     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessCheckFileType), NULL, NULL
 106 },
 107 ProcessOldDrawerDataHook =
 108 {
 109     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessOldDrawerData), NULL, NULL
 110 },
 111 ProcessNewDrawerDataHook =
 112 {
 113     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessNewDrawerData), NULL, NULL
 114 },
 115 ProcessGadgetRenderHook =
 116 {
 117     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessGadgetRender), NULL, NULL
 118 },
 119 ProcessSelectRenderHook =
 120 {
 121     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessSelectRender), NULL, NULL
 122 },
 123 ProcessFlagPtrHook =
 124 {
 125     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessFlagPtr), NULL, NULL
 126 },
 127 ProcessDefaultToolHook =
 128 {
 129     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessDefaultTool), NULL, NULL
 130 },
 131 ProcessToolWindowHook =
 132 {
 133     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessToolWindow), NULL, NULL
 134 },
 135 ProcessToolTypesHook =
 136 {
 137     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessToolTypes), NULL, NULL
 138 },
 139 ProcessIcon35Hook =
 140 {
 141     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessIcon35), NULL, NULL
 142 },
 143 ProcessIconNIHook =
 144 {
 145     { NULL, NULL}, (HOOKFUNC)AROS_ASMSYMNAME(ProcessIconNI), NULL, NULL
 146 };
 147
 148 /****************************************************************************************/
 149
 150 #undef O
 151 #define O(x)    (offsetof (struct Gadget,x))
 152
 153 /****************************************************************************************/
 154
 155 static const IPTR GadgetDesc[] =
 156 {
 157     sizeof (struct Gadget),
 158     SDM_IGNORE(4), /* NextGadget */
 159     SDM_WORD(O(LeftEdge)),
 160     SDM_WORD(O(TopEdge)),
 161     SDM_WORD(O(Width)),
 162     SDM_WORD(O(Height)),
 163     SDM_UWORD(O(Flags)),
 164     SDM_UWORD(O(Activation)),
 165     SDM_UWORD(O(GadgetType)),
 166     SDM_SPECIAL(O(GadgetRender),&ProcessFlagPtrHook),
 167     SDM_SPECIAL(O(SelectRender),&ProcessFlagPtrHook),
 168     SDM_SPECIAL(O(GadgetText),&ProcessFlagPtrHook),
 169     SDM_LONG(O(MutualExclude)),
 170     SDM_SPECIAL(O(SpecialInfo),&ProcessFlagPtrHook),
 171     SDM_UWORD(O(GadgetID)),
 172     SDM_ULONG(O(UserData)),
 173     SDM_END
 174 };
 175
 176 /****************************************************************************************/
 177
 178 #undef O
 179 #define O(x)    (offsetof (struct DiskObject,x))
 180
 181 /****************************************************************************************/
 182
 183 static const IPTR DiskObjectDesc[] =
 184 {
 185     sizeof (struct DiskObject),
 186     SDM_UWORD(O(do_Magic)),
 187     SDM_UWORD(O(do_Version)),
 188     SDM_STRUCT(O(do_Gadget),GadgetDesc),
 189     SDM_UBYTE(O(do_Type)),
 190     SDM_IGNORE(1), /* Pad */
 191     SDM_SPECIAL(O(do_DefaultTool),&ProcessFlagPtrHook),
 192     SDM_SPECIAL(O(do_ToolTypes),&ProcessFlagPtrHook),
 193     SDM_LONG(O(do_CurrentX)),
 194     SDM_LONG(O(do_CurrentY)),
 195     SDM_SPECIAL(O(do_DrawerData),&ProcessFlagPtrHook),
 196     SDM_SPECIAL(O(do_ToolWindow),&ProcessFlagPtrHook),
 197     SDM_LONG(O(do_StackSize)),
 198     SDM_END
 199 };
 200
 201 /****************************************************************************************/
 202
 203 #undef O
 204 #define O(x)    (offsetof (struct Image,x))
 205
 206 /****************************************************************************************/
 207
 208 static const IPTR ImageDesc[] =
 209 {
 210     sizeof (struct Image),
 211     SDM_WORD(O(LeftEdge)),
 212     SDM_WORD(O(TopEdge)),
 213     SDM_WORD(O(Width)),
 214     SDM_WORD(O(Height)),
 215     SDM_WORD(O(Depth)),
 216     SDM_SPECIAL(O(ImageData),&ProcessFlagPtrHook),
 217     SDM_UBYTE(O(PlanePick)),
 218     SDM_UBYTE(O(PlaneOnOff)),
 219     SDM_SPECIAL(O(NextImage),&ProcessFlagPtrHook),
 220     SDM_END
 221 };
 222
 223 /****************************************************************************************/
 224
 225 const IPTR IconDesc[] =
 226 {
 227     sizeof (struct NativeIcon),
 228     SDM_STRUCT(0,DiskObjectDesc),
 229     SDM_SPECIAL(0,&ProcessCheckFileTypeHook),
 230     SDM_SPECIAL(0,&ProcessOldDrawerDataHook),
 231     SDM_SPECIAL(0,&ProcessGadgetRenderHook),
 232     SDM_SPECIAL(0,&ProcessSelectRenderHook),
 233     SDM_SPECIAL(0,&ProcessDefaultToolHook),
 234     SDM_SPECIAL(0,&ProcessToolTypesHook),
 235     SDM_SPECIAL(0,&ProcessToolWindowHook),
 236     SDM_SPECIAL(0,&ProcessNewDrawerDataHook),
 237     SDM_SPECIAL(0,&ProcessIcon35Hook),
 238     SDM_SPECIAL(0,&ProcessIconNIHook),
 239     SDM_END
 240 };
 241
 242 /****************************************************************************************/
 243
 244 #undef O
 245 #define O(x)    (offsetof (struct NewWindow,x))
 246
 247 /****************************************************************************************/
 248
 249 const IPTR NewWindowDesc[] =
 250 {
 251     sizeof (struct NewWindow),
 252     SDM_WORD(O(LeftEdge)),
 253     SDM_WORD(O(TopEdge)),
 254     SDM_WORD(O(Width)),
 255     SDM_WORD(O(Height)),
 256     SDM_UBYTE(O(DetailPen)),
 257     SDM_UBYTE(O(BlockPen)),
 258     SDM_ULONG(O(IDCMPFlags)),
 259     SDM_ULONG(O(Flags)),
 260     SDM_IGNORE(4+4+4+4+4), /* FirstGadget
 261             +CheckMark
 262             +Title
 263             +Screen
 264             +BitMap
 265             */
 266     SDM_WORD(O(MinWidth)),
 267     SDM_WORD(O(MinHeight)),
 268     SDM_UWORD(O(MaxWidth)),
 269     SDM_UWORD(O(MaxHeight)),
 270     SDM_UWORD(O(Type)),
 271     SDM_END
 272 };
 273
 274 /****************************************************************************************/
 275
 276 #undef O
 277 #define O(x)    (offsetof (struct DrawerData,x))
 278
 279 /****************************************************************************************/
 280
 281 const IPTR OldDrawerDataDesc[] =
 282 {
 283     sizeof (struct DrawerData),
 284     SDM_STRUCT(O(dd_NewWindow),NewWindowDesc),
 285     SDM_LONG(O(dd_CurrentX)),
 286     SDM_LONG(O(dd_CurrentY)),
 287     SDM_END
 288 };
 289
 290 /****************************************************************************************/
 291
 292 AROS_UFH3(LONG, dosstreamhook,
 293     AROS_UFHA(struct Hook *, hook, A0),
 294     AROS_UFHA(BPTR,          fh,   A2),
 295     AROS_UFHA(ULONG       *, msg,  A1)
 296 )
 297 {
 298     AROS_USERFUNC_INIT
 299
 300     struct IconBase *IconBase = hook->h_Data;
 301
 302     LONG rc = 0;
 303
 304     switch (*msg)
 305     {
 306     case BEIO_READ:
 307         rc = FGetC (fh);
 308 #if 0
 309 kprintf ("dsh: Read: %02X\n", rc);
 310 #endif
 311         break;
 312
 313     case BEIO_WRITE:
 314         rc = FPutC (fh, ((struct BEIOM_Write *)msg)->Data);
 315         break;
 316
 317     case BEIO_IGNORE:
 318         Flush (fh);
 319
 320         rc = Seek (fh, ((struct BEIOM_Ignore *)msg)->Count, OFFSET_CURRENT);
 321 #if 0
 322 kprintf ("dsh: Skip %d\n", ((struct BEIOM_Ignore *)msg)->Count);
 323 #endif
 324         break;
 325
 326     }
 327
 328     return rc;
 329
 330     AROS_USERFUNC_EXIT
 331 } /* dosstreamhook */
 332
 333 /****************************************************************************************/
 334
 335 #define DO(x)       ((struct DiskObject *)x)
 336
 337 /****************************************************************************************/
 338
 339 AROS_UFH3S(ULONG, ProcessCheckFileType,
 340     AROS_UFHA(struct Hook *,   hook, A0),
 341     AROS_UFHA(struct Hook *,   streamhook, A2),
 342     AROS_UFHA(struct SDData *, data, A1)
 343 )
 344 {
 345     AROS_USERFUNC_INIT
 346
 347     struct DiskObject *icon = DO(data->sdd_Dest);
 348
 349     if (data->sdd_Mode == SDV_SPECIALMODE_READ)
 350     {
 351         if ((icon->do_Magic != WB_DISKMAGIC))
 352         {
 353             return FALSE;
 354         }
 355     }
 356
 357     return TRUE;
 358
 359     AROS_USERFUNC_EXIT
 360
 361 }
 362
 363 /****************************************************************************************/
 364
 365 AROS_UFH3S(ULONG, ProcessOldDrawerData,
 366     AROS_UFHA(struct Hook *,   hook, A0),
 367     AROS_UFHA(struct Hook *,   streamhook, A2),
 368     AROS_UFHA(struct SDData *, data, A1)
 369 )
 370 {
 371     AROS_USERFUNC_INIT
 372
 373     APTR ptr;
 374     struct IconBase *IconBase = streamhook->h_Data;
 375     struct DiskObject *icon = DO(data->sdd_Dest);
 376
 377 #if 0
 378 kprintf ("ProcessOldDrawerData\n");
 379 #endif
 380
 381 /*    if (icon->do_Type == WBDRAWER)
 382 */
 383     /* sba: all icons which have do_DrawerData set actually contain
 384      * also the drawer data */
 385
 386     if (icon->do_DrawerData)
 387     {
 388         switch (data->sdd_Mode)
 389         {
 390         case SDV_SPECIALMODE_READ:
 391             ptr = AllocMemIcon(icon, sizeof(struct DrawerData), MEMF_PUBLIC,
 392                 IconBase);
 393             if (ptr == NULL)
 394                 return FALSE;
 395
 396             if (ReadStruct (streamhook
 397                 , (APTR *)&ptr
 398                 , data->sdd_Stream
 399                 , OldDrawerDataDesc
 400                 ))
 401             {
 402                 icon->do_DrawerData = ptr;
 403                 NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_OLDDRAWERDATA_READ;
 404                 return TRUE;
 405             }
 406             return FALSE;
 407
 408         case SDV_SPECIALMODE_WRITE:
 409             return WriteStruct (streamhook
 410                 , icon->do_DrawerData
 411                 , data->sdd_Stream
 412                 , OldDrawerDataDesc
 413             );
 414         case SDV_SPECIALMODE_FREE:
 415             return TRUE;
 416         }
 417     }
 418
 419     return TRUE;
 420
 421     AROS_USERFUNC_EXIT
 422 } /* ProcessOldDrawerData */
 423
 424 /****************************************************************************************/
 425
 426 static struct Image * ReadImage (struct DiskObject *icon, struct Hook * streamhook, BPTR file)
 427 {
 428     struct Image * image;
 429     ULONG          size;
 430     ULONG          t;
 431     struct IconBase *IconBase = streamhook->h_Data;
 432
 433     image = AllocMemIcon(icon, sizeof(struct Image),
 434         MEMF_PUBLIC | MEMF_CLEAR, IconBase);
 435     if (!image)
 436         return NULL;
 437
 438     if (!ReadStruct (streamhook, (APTR *)&image, (APTR)file, ImageDesc))
 439         return NULL;
 440
 441     /* Size of imagedata in bytes */
 442     size = ((image->Width + 15) >> 4) * image->Height * image->Depth * 2;
 443
 444     D(bug("%s: %dx%dx%d (%d bytes)\n", __func__
 445             , image->Width
 446             , image->Height
 447             , image->Depth
 448             , size));
 449
 450     if (size)
 451     {
 452         if (!(image->ImageData = AllocMemIcon(icon, size,
 453             MEMF_PUBLIC | MEMF_CHIP, IconBase)))
 454             return NULL;
 455
 456         size >>= 1;
 457
 458         for (t=0; t<size; t++)
 459         {
 460             UWORD data;
 461
 462             if (!ReadWord (streamhook, &data, (APTR)file))
 463                 break;
 464
 465             image->ImageData[t] = AROS_WORD2BE(data);
 466         }
 467
 468         if (t != size)
 469         {
 470             D(bug("[%s] Strange. Short read at %d, expected %d\n", t, size));
 471             return NULL;
 472         }
 473     }
 474
 475     return image;
 476 } /* ReadImage */
 477
 478 /****************************************************************************************/
 479
 480 static int WriteImage (struct Hook * streamhook, BPTR file,
 481         struct Image * image)
 482 {
 483     ULONG size;
 484     ULONG t;
 485
 486     if (!WriteStruct (streamhook, image, (APTR)file, ImageDesc) )
 487         return FALSE;
 488
 489     /* Get size in words */
 490     size = ((image->Width + 15) >> 4) * image->Height * image->Depth;
 491
 492 #if 0
 493 kprintf ("WriteImage: %dx%dx%d (%d bytes)\n"
 494     , image->Width
 495     , image->Height
 496     , image->Depth
 497     , size*2
 498 );
 499 #endif
 500
 501     for (t=0; t<size; t++)
 502     {
 503         UWORD data = image->ImageData[t];
 504
 505         if (!WriteWord (streamhook, AROS_WORD2BE(data), (APTR)file))
 506             break;
 507     }
 508
 509     return (t == size);
 510 } /* WriteImage */
 511
 512 /****************************************************************************************/
 513
 514 AROS_UFH3S(ULONG, ProcessGadgetRender,
 515     AROS_UFHA(struct Hook *,   hook, A0),
 516     AROS_UFHA(struct Hook *,   streamhook, A2),
 517     AROS_UFHA(struct SDData *, data, A1)
 518 )
 519 {
 520     AROS_USERFUNC_INIT
 521
 522     struct Image * image;
 523     struct DiskObject *icon = DO(data->sdd_Dest);
 524
 525 #if 0
 526 kprintf ("ProcessGadgetRender\n");
 527 #endif
 528
 529     if (icon->do_Gadget.GadgetRender || (icon->do_Gadget.Flags & GFLG_GADGIMAGE))
 530     {
 531         switch (data->sdd_Mode)
 532         {
 533         case SDV_SPECIALMODE_READ:
 534             image = ReadImage (icon, streamhook, (BPTR)data->sdd_Stream);
 535
 536             if (!image)
 537                 return FALSE;
 538
 539             icon->do_Gadget.GadgetRender = image;
 540             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_GADGETIMAGE_READ;
 541             break;
 542
 543         case SDV_SPECIALMODE_WRITE:
 544             image = icon->do_Gadget.GadgetRender;
 545             if (!image)
 546                 return TRUE;
 547
 548             return WriteImage (streamhook, (BPTR)data->sdd_Stream, image);
 549
 550         case SDV_SPECIALMODE_FREE:
 551             break;
 552         }
 553     }
 554
 555     return TRUE;
 556
 557     AROS_USERFUNC_EXIT
 558 } /* ProcessGadgetRender */
 559
 560 /****************************************************************************************/
 561
 562 AROS_UFH3S(ULONG, ProcessSelectRender,
 563     AROS_UFHA(struct Hook *,   hook, A0),
 564     AROS_UFHA(struct Hook *,   streamhook, A2),
 565     AROS_UFHA(struct SDData *, data, A1)
 566 )
 567 {
 568     AROS_USERFUNC_INIT
 569
 570     struct Image * image;
 571     struct DiskObject *icon = DO(data->sdd_Dest);
 572
 573 #if 0
 574 kprintf ("ProcessSelectRender\n");
 575 #endif
 576
 577     /* Not all icon with second image seem to have GFLG_GADGHIMAGE set */
 578
 579     if (icon->do_Gadget.SelectRender || (icon->do_Gadget.Flags & GFLG_GADGHIMAGE))
 580     {
 581         switch (data->sdd_Mode)
 582         {
 583         case SDV_SPECIALMODE_READ:
 584             image = ReadImage (icon, streamhook, (BPTR)data->sdd_Stream);
 585
 586             if (!image)
 587                 return FALSE;
 588
 589             icon->do_Gadget.SelectRender = image;
 590             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_SELECTIMAGE_READ;
 591             break;
 592
 593         case SDV_SPECIALMODE_WRITE:
 594             image = icon->do_Gadget.SelectRender;
 595
 596             return WriteImage (streamhook, (BPTR)data->sdd_Stream, image);
 597
 598         case SDV_SPECIALMODE_FREE:
 599             break;
 600         }
 601     }
 602
 603     return TRUE;
 604
 605     AROS_USERFUNC_EXIT
 606 } /* ProcessSelectRender */
 607
 608 /****************************************************************************************/
 609
 610 AROS_UFH3S(ULONG, ProcessFlagPtr,
 611     AROS_UFHA(struct Hook *,   hook, A0),
 612     AROS_UFHA(struct Hook *,   streamhook, A2),
 613     AROS_UFHA(struct SDData *, data, A1)
 614 )
 615 {
 616     AROS_USERFUNC_INIT
 617
 618     LONG ptr;
 619     struct IconBase *IconBase = streamhook->h_Data;
 620
 621     switch (data->sdd_Mode)
 622     {
 623     case SDV_SPECIALMODE_READ:
 624         if (FRead ((BPTR)data->sdd_Stream, &ptr, 1, 4) != 4)
 625             return FALSE;
 626
 627 #if 0
 628 kprintf ("ProcessFlagPtr: %08lx %ld\n", ptr);
 629 #endif
 630
 631         *((IPTR *)data->sdd_Dest) = (IPTR)(ptr != 0L);
 632
 633         break;
 634
 635     case SDV_SPECIALMODE_WRITE:
 636         IconBase = streamhook->h_Data;
 637         if (*((APTR *)data->sdd_Dest))
 638             ptr = 0xABADCAFEL;
 639         else
 640             ptr = 0L;
 641
 642         if (FWrite ((BPTR)data->sdd_Stream, &ptr, 1, 4) != 4)
 643             return FALSE;
 644
 645         break;
 646
 647     case SDV_SPECIALMODE_FREE:
 648         break;
 649     }
 650
 651
 652     return TRUE;
 653
 654     AROS_USERFUNC_EXIT
 655 } /* ProcessFlagPtr */
 656
 657 /****************************************************************************************/
 658
 659 static STRPTR ReadIconString (struct DiskObject *icon, struct Hook * streamhook, BPTR file)
 660 {
 661     ULONG  len;
 662     STRPTR str;
 663
 664     struct IconBase *IconBase = streamhook->h_Data;
 665
 666     if (!ReadLong (streamhook, &len, (APTR)file))
 667         return NULL;
 668
 669     str = AllocMemIcon(icon, len, MEMF_PUBLIC, IconBase);
 670
 671     if (!str)
 672         return NULL;
 673
 674     if (FRead ((BPTR)file, str, len, 1) == EOF)
 675     {
 676         return NULL;
 677     }
 678
 679 #if 0
 680 kprintf ("ReadIconString: \"%s\"\n", str);
 681 #endif
 682
 683     return str;
 684 } /* ReadIconString */
 685
 686 /****************************************************************************************/
 687
 688 static int WriteIconString (struct Hook * streamhook, BPTR file, STRPTR str)
 689 {
 690     ULONG len;
 691
 692     struct IconBase *IconBase = streamhook->h_Data;
 693
 694     len = strlen (str) + 1;
 695
 696     if (!WriteLong (streamhook, len, (APTR)file))
 697         return FALSE;
 698
 699     return FWrite (file, str, len, 1) != EOF;
 700 } /* WriteIconString */
 701
 702 /****************************************************************************************/
 703
 704 AROS_UFH3S(ULONG, ProcessDefaultTool,
 705     AROS_UFHA(struct Hook *,   hook, A0),
 706     AROS_UFHA(struct Hook *,   streamhook, A2),
 707     AROS_UFHA(struct SDData *, data, A1)
 708 )
 709 {
 710     AROS_USERFUNC_INIT
 711
 712     STRPTR str;
 713     struct DiskObject *icon = DO(data->sdd_Dest);
 714
 715 #if 0
 716 kprintf ("ProcessDefaultTool\n");
 717 #endif
 718
 719     if (icon->do_DefaultTool)
 720     {
 721         switch (data->sdd_Mode)
 722         {
 723         case SDV_SPECIALMODE_READ:
 724             str = ReadIconString (icon, streamhook, (BPTR) data->sdd_Stream);
 725
 726             if (!str)
 727                 return FALSE;
 728
 729             icon->do_DefaultTool = str;
 730             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_DEFAULTTOOL_READ;
 731             break;
 732
 733         case SDV_SPECIALMODE_WRITE: {
 734             str = icon->do_DefaultTool;
 735
 736             WriteIconString (streamhook, (BPTR) data->sdd_Stream, str);
 737
 738             break; }
 739
 740         case SDV_SPECIALMODE_FREE:
 741             break;
 742         }
 743     }
 744
 745     return TRUE;
 746
 747     AROS_USERFUNC_EXIT
 748 } /* ProcessDefaultTool */
 749
 750 /****************************************************************************************/
 751
 752 AROS_UFH3S(ULONG, ProcessToolWindow,
 753     AROS_UFHA(struct Hook *,   hook, A0),
 754     AROS_UFHA(struct Hook *,   streamhook, A2),
 755     AROS_UFHA(struct SDData *, data, A1)
 756 )
 757 {
 758     AROS_USERFUNC_INIT
 759
 760     STRPTR str;
 761     struct DiskObject *icon = DO(data->sdd_Dest);
 762
 763 #if 0
 764 kprintf ("ProcessToolWindow\n");
 765 #endif
 766
 767     if (icon->do_ToolWindow)
 768     {
 769         switch (data->sdd_Mode)
 770         {
 771         case SDV_SPECIALMODE_READ:
 772             str = ReadIconString (icon, streamhook, (BPTR)data->sdd_Stream);
 773
 774             if (!str)
 775                 return FALSE;
 776
 777             icon->do_ToolWindow = str;
 778             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_TOOLWINDOW_READ;
 779             break;
 780
 781         case SDV_SPECIALMODE_WRITE: {
 782             str = icon->do_ToolWindow;
 783
 784             WriteIconString (streamhook, (BPTR)data->sdd_Stream, str);
 785
 786             break; }
 787
 788         case SDV_SPECIALMODE_FREE:
 789             break;
 790         }
 791     }
 792
 793     return TRUE;
 794
 795     AROS_USERFUNC_EXIT
 796 } /* ProcessToolWindow */
 797
 798 /****************************************************************************************/
 799
 800 AROS_UFH3S(ULONG, ProcessToolTypes,
 801     AROS_UFHA(struct Hook *,   hook, A0),
 802     AROS_UFHA(struct Hook *,   streamhook, A2),
 803     AROS_UFHA(struct SDData *, data, A1)
 804 )
 805 {
 806     AROS_USERFUNC_INIT
 807
 808     struct IconBase *IconBase = streamhook->h_Data;
 809     struct DiskObject *icon = DO(data->sdd_Dest);
 810
 811 #if 0
 812 kprintf ("ProcessToolTypes\n");
 813 #endif
 814
 815     if (icon->do_ToolTypes)
 816     {
 817         ULONG    t;
 818         ULONG    count;
 819         STRPTR * ttarray;
 820
 821         switch (data->sdd_Mode)
 822         {
 823         case SDV_SPECIALMODE_READ:
 824             /* Read size of ToolTypes array (each entry is 4 bytes and the
 825                last is 0L */
 826             if (!ReadLong (streamhook, &count, data->sdd_Stream))
 827                 return FALSE;
 828
 829             count = (count >> 2) - 1; /* How many entries */
 830
 831             if ((LONG)count < 0)
 832             {
 833                 icon->do_ToolTypes = NULL;
 834                 return TRUE;
 835             }
 836
 837             ttarray = AllocMemIcon(icon, (count+1)*sizeof(STRPTR),
 838                 MEMF_PUBLIC, IconBase);
 839             if (!ttarray) return FALSE;
 840
 841 #if 0
 842 kprintf ("Read %d tooltypes (tt=%p)\n", count, ttarray);
 843 #endif
 844
 845             for (t=0; t<count; t++)
 846             {
 847                 ttarray[t] = ReadIconString (icon, streamhook, (BPTR)data->sdd_Stream);
 848 #if 0
 849 kprintf ("String %d=%p=%s\n", t, ttarray[t], ttarray[t]);
 850 #endif
 851
 852                 if (!ttarray[t])
 853                     return FALSE;
 854             }
 855
 856             ttarray[t] = NULL;
 857
 858             icon->do_ToolTypes = (STRPTR *)ttarray;
 859             NATIVEICON(icon)->ni_ReadStruct_State |= RSS_TOOLTYPES_READ;
 860             break;
 861
 862         case SDV_SPECIALMODE_WRITE: {
 863             ULONG size;
 864
 865             ttarray = (STRPTR *)icon->do_ToolTypes;
 866
 867             for (count=0; ttarray[count]; count++);
 868
 869 #if 0
 870 kprintf ("Write %d tooltypes (%p)\n", count, ttarray);
 871 #endif
 872
 873             size = (count+1)*4;
 874
 875             if (!WriteLong (streamhook, size, data->sdd_Stream))
 876                 return FALSE;
 877
 878             for (t=0; t<count; t++)
 879             {
 880 #if 0
 881 kprintf ("String %d=%p=%s\n", t, ttarray[t], ttarray[t]);
 882 #endif
 883                 if (!WriteIconString (streamhook, (BPTR)data->sdd_Stream, ttarray[t]))
 884                     return FALSE;
 885             }
 886
 887             break; }
 888
 889         case SDV_SPECIALMODE_FREE:
 890             break;
 891         }
 892     }
 893 #if 0
 894     else
 895         kprintf ("No tool types\n");
 896 #endif
 897
 898     return TRUE;
 899
 900     AROS_USERFUNC_EXIT
 901 } /* ProcessToolTypes */
 902
 903 /****************************************************************************************/
 904
 905 AROS_UFH3S(ULONG, ProcessNewDrawerData,
 906     AROS_UFHA(struct Hook *,   hook, A0),
 907     AROS_UFHA(struct Hook *,   streamhook, A2),
 908     AROS_UFHA(struct SDData *, data, A1)
 909 )
 910 {
 911     AROS_USERFUNC_INIT
 912
 913     struct DiskObject *icon = DO(data->sdd_Dest);
 914     IPTR rev = (IPTR)icon->do_Gadget.UserData & WB_DISKREVISIONMASK;
 915 #if 0
 916 kprintf ("ProcessNewDrawerData\n");
 917 #endif
 918
 919     if (icon->do_DrawerData && (rev > 0) && (rev <= WB_DISKREVISION))
 920     {
 921         switch (data->sdd_Mode)
 922         {
 923         case SDV_SPECIALMODE_READ:
 924             if (!ReadLong(streamhook, &icon->do_DrawerData->dd_Flags, data->sdd_Stream))
 925                 return FALSE;
 926
 927             if (!ReadWord(streamhook, &icon->do_DrawerData->dd_ViewModes, data->sdd_Stream))
 928                 return FALSE;
 929
 930             break;
 931
 932         case SDV_SPECIALMODE_WRITE:
 933             if (!WriteLong(streamhook, icon->do_DrawerData->dd_Flags, data->sdd_Stream))
 934                 return FALSE;
 935
 936             if (!WriteWord(streamhook, icon->do_DrawerData->dd_ViewModes, data->sdd_Stream))
 937                 return FALSE;
 938             break;
 939         }
 940     }
 941
 942     return TRUE;
 943
 944     AROS_USERFUNC_EXIT
 945 } /* ProcessNewDrawerData */
 946
 947 /****************************************************************************************/
 948
 949 #define IconBase ((IconBase_T *)(streamhook->h_Data))
 950
 951 /****************************************************************************************/
 952
 953 AROS_UFH3S(ULONG, ProcessIcon35,
 954     AROS_UFHA(struct Hook *,   hook, A0),
 955     AROS_UFHA(struct Hook *,   streamhook, A2),
 956     AROS_UFHA(struct SDData *, data, A1)
 957 )
 958 {
 959     AROS_USERFUNC_INIT
 960
 961     IPTR retval = TRUE;
 962
 963 #if 0
 964 kprintf ("ProcessIcon35\n");
 965 #endif
 966
 967     switch (data->sdd_Mode)
 968     {
 969         case SDV_SPECIALMODE_READ:
 970             ReadIcon35(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
 971             break;
 972
 973         case SDV_SPECIALMODE_FREE:
 974             FreeIcon35(NATIVEICON(DO(data->sdd_Dest)), IconBase);
 975             break;
 976
 977         case SDV_SPECIALMODE_WRITE:
 978             retval = WriteIcon35(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
 979             break;
 980
 981     }
 982
 983     return retval;
 984
 985     AROS_USERFUNC_EXIT
 986 } /* ProcessIcon35 */
 987
 988 /****************************************************************************************/
 989
 990 AROS_UFH3S(ULONG, ProcessIconNI,
 991     AROS_UFHA(struct Hook *,   hook, A0),
 992     AROS_UFHA(struct Hook *,   streamhook, A2),
 993     AROS_UFHA(struct SDData *, data, A1)
 994 )
 995 {
 996     AROS_USERFUNC_INIT
 997
 998     IPTR retval = TRUE;
 999
1000 #if 0
1001 kprintf ("ProcessIconNI\n");
1002 #endif
1003
1004     switch (data->sdd_Mode)
1005     {
1006         case SDV_SPECIALMODE_READ:
1007             ReadIconNI(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
1008             break;
1009
1010         case SDV_SPECIALMODE_FREE:
1011             FreeIconNI(NATIVEICON(DO(data->sdd_Dest)), IconBase);
1012             break;
1013
1014         case SDV_SPECIALMODE_WRITE:
1015             retval = WriteIconNI(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
1016             break;
1017
1018     }
1019
1020     return retval;
1021
1022     AROS_USERFUNC_EXIT
1023 } /* ProcessIconNI */
1024
1025 /****************************************************************************************/
1026