workbench/libs/icon/diskobjio.c

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