workbench/libs/icon/diskobjio.c

   1 /*
   2     Copyright © 1995-2010, 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             if (ptr == NULL)
 393                 return FALSE;
 394
 395             if (ReadStruct (streamhook
 396                 , (APTR *)&ptr
 397                 , data->sdd_Stream
 398                 , OldDrawerDataDesc
 399                 ))
 400             {
 401                 icon->do_DrawerData = ptr;
 402                 NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_OLDDRAWERDATA_READ;
 403                 return TRUE;
 404             }
 405             return FALSE;
 406
 407         case SDV_SPECIALMODE_WRITE:
 408             return WriteStruct (streamhook
 409                 , icon->do_DrawerData
 410                 , data->sdd_Stream
 411                 , OldDrawerDataDesc
 412             );
 413         case SDV_SPECIALMODE_FREE:
 414             return TRUE;
 415         }
 416     }
 417
 418     return TRUE;
 419
 420     AROS_USERFUNC_EXIT
 421 } /* ProcessOldDrawerData */
 422
 423 /****************************************************************************************/
 424
 425 static struct Image * ReadImage (struct DiskObject *icon, struct Hook * streamhook, BPTR file)
 426 {
 427     struct Image * image;
 428     ULONG          size;
 429     ULONG          t;
 430     struct IconBase *IconBase = streamhook->h_Data;
 431
 432     image = AllocMemIcon(icon, sizeof(struct Image), MEMF_PUBLIC | MEMF_CLEAR);
 433     if (!image)
 434         return NULL;
 435
 436     if (!ReadStruct (streamhook, (APTR *)&image, (APTR)file, ImageDesc))
 437         return NULL;
 438
 439     /* Size of imagedata in bytes */
 440     size = ((image->Width + 15) >> 4) * image->Height * image->Depth * 2;
 441
 442     D(bug("%s: %dx%dx%d (%d bytes)\n", __func__
 443             , image->Width
 444             , image->Height
 445             , image->Depth
 446             , size));
 447
 448     if (size)
 449     {
 450         if (!(image->ImageData = AllocMemIcon(icon, size, MEMF_PUBLIC | MEMF_CHIP)) )
 451             return NULL;
 452
 453         size >>= 1;
 454
 455         for (t=0; t<size; t++)
 456         {
 457             UWORD data;
 458
 459             if (!ReadWord (streamhook, &data, (APTR)file))
 460                 break;
 461
 462             image->ImageData[t] = AROS_WORD2BE(data);
 463         }
 464
 465         if (t != size)
 466         {
 467             D(bug("[%s] Strange. Short read at %d, expected %d\n", t, size));
 468             return NULL;
 469         }
 470     }
 471
 472     return image;
 473 } /* ReadImage */
 474
 475 /****************************************************************************************/
 476
 477 static int WriteImage (struct Hook * streamhook, BPTR file,
 478         struct Image * image)
 479 {
 480     ULONG size;
 481     ULONG t;
 482
 483     if (!WriteStruct (streamhook, image, (APTR)file, ImageDesc) )
 484         return FALSE;
 485
 486     /* Get size in words */
 487     size = ((image->Width + 15) >> 4) * image->Height * image->Depth;
 488
 489 #if 0
 490 kprintf ("WriteImage: %dx%dx%d (%d bytes)\n"
 491     , image->Width
 492     , image->Height
 493     , image->Depth
 494     , size*2
 495 );
 496 #endif
 497
 498     for (t=0; t<size; t++)
 499     {
 500         UWORD data = image->ImageData[t];
 501
 502         if (!WriteWord (streamhook, AROS_WORD2BE(data), (APTR)file))
 503             break;
 504     }
 505
 506     return (t == size);
 507 } /* WriteImage */
 508
 509 /****************************************************************************************/
 510
 511 AROS_UFH3S(ULONG, ProcessGadgetRender,
 512     AROS_UFHA(struct Hook *,   hook, A0),
 513     AROS_UFHA(struct Hook *,   streamhook, A2),
 514     AROS_UFHA(struct SDData *, data, A1)
 515 )
 516 {
 517     AROS_USERFUNC_INIT
 518
 519     struct Image * image;
 520     struct DiskObject *icon = DO(data->sdd_Dest);
 521
 522 #if 0
 523 kprintf ("ProcessGadgetRender\n");
 524 #endif
 525
 526     if (icon->do_Gadget.GadgetRender || (icon->do_Gadget.Flags & GFLG_GADGIMAGE))
 527     {
 528         switch (data->sdd_Mode)
 529         {
 530         case SDV_SPECIALMODE_READ:
 531             image = ReadImage (icon, streamhook, (BPTR)data->sdd_Stream);
 532
 533             if (!image)
 534                 return FALSE;
 535
 536             icon->do_Gadget.GadgetRender = image;
 537             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_GADGETIMAGE_READ;
 538             break;
 539
 540         case SDV_SPECIALMODE_WRITE:
 541             image = icon->do_Gadget.GadgetRender;
 542             if (!image)
 543                 return TRUE;
 544
 545             return WriteImage (streamhook, (BPTR)data->sdd_Stream, image);
 546
 547         case SDV_SPECIALMODE_FREE:
 548             break;
 549         }
 550     }
 551
 552     return TRUE;
 553
 554     AROS_USERFUNC_EXIT
 555 } /* ProcessGadgetRender */
 556
 557 /****************************************************************************************/
 558
 559 AROS_UFH3S(ULONG, ProcessSelectRender,
 560     AROS_UFHA(struct Hook *,   hook, A0),
 561     AROS_UFHA(struct Hook *,   streamhook, A2),
 562     AROS_UFHA(struct SDData *, data, A1)
 563 )
 564 {
 565     AROS_USERFUNC_INIT
 566
 567     struct Image * image;
 568     struct DiskObject *icon = DO(data->sdd_Dest);
 569
 570 #if 0
 571 kprintf ("ProcessSelectRender\n");
 572 #endif
 573
 574     /* Not all icon with second image seem to have GFLG_GADGHIMAGE set */
 575
 576     if (icon->do_Gadget.SelectRender || (icon->do_Gadget.Flags & GFLG_GADGHIMAGE))
 577     {
 578         switch (data->sdd_Mode)
 579         {
 580         case SDV_SPECIALMODE_READ:
 581             image = ReadImage (icon, streamhook, (BPTR)data->sdd_Stream);
 582
 583             if (!image)
 584                 return FALSE;
 585
 586             icon->do_Gadget.SelectRender = image;
 587             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_SELECTIMAGE_READ;
 588             break;
 589
 590         case SDV_SPECIALMODE_WRITE:
 591             image = icon->do_Gadget.SelectRender;
 592
 593             return WriteImage (streamhook, (BPTR)data->sdd_Stream, image);
 594
 595         case SDV_SPECIALMODE_FREE:
 596             break;
 597         }
 598     }
 599
 600     return TRUE;
 601
 602     AROS_USERFUNC_EXIT
 603 } /* ProcessSelectRender */
 604
 605 /****************************************************************************************/
 606
 607 AROS_UFH3S(ULONG, ProcessFlagPtr,
 608     AROS_UFHA(struct Hook *,   hook, A0),
 609     AROS_UFHA(struct Hook *,   streamhook, A2),
 610     AROS_UFHA(struct SDData *, data, A1)
 611 )
 612 {
 613     AROS_USERFUNC_INIT
 614
 615     LONG ptr;
 616     struct IconBase *IconBase = streamhook->h_Data;
 617
 618     switch (data->sdd_Mode)
 619     {
 620     case SDV_SPECIALMODE_READ:
 621         if (FRead ((BPTR)data->sdd_Stream, &ptr, 1, 4) != 4)
 622             return FALSE;
 623
 624 #if 0
 625 kprintf ("ProcessFlagPtr: %08lx %ld\n", ptr);
 626 #endif
 627
 628         *((IPTR *)data->sdd_Dest) = (IPTR)(ptr != 0L);
 629
 630         break;
 631
 632     case SDV_SPECIALMODE_WRITE:
 633         IconBase = streamhook->h_Data;
 634         if (*((APTR *)data->sdd_Dest))
 635             ptr = 0xABADCAFEL;
 636         else
 637             ptr = 0L;
 638
 639         if (FWrite ((BPTR)data->sdd_Stream, &ptr, 1, 4) != 4)
 640             return FALSE;
 641
 642         break;
 643
 644     case SDV_SPECIALMODE_FREE:
 645         break;
 646     }
 647
 648
 649     return TRUE;
 650
 651     AROS_USERFUNC_EXIT
 652 } /* ProcessFlagPtr */
 653
 654 /****************************************************************************************/
 655
 656 static STRPTR ReadIconString (struct DiskObject *icon, struct Hook * streamhook, BPTR file)
 657 {
 658     ULONG  len;
 659     STRPTR str;
 660
 661     struct IconBase *IconBase = streamhook->h_Data;
 662
 663     if (!ReadLong (streamhook, &len, (APTR)file))
 664         return NULL;
 665
 666     str = AllocMemIcon(icon, len, MEMF_PUBLIC);
 667
 668     if (!str)
 669         return NULL;
 670
 671     if (FRead ((BPTR)file, str, len, 1) == EOF)
 672     {
 673         return NULL;
 674     }
 675
 676 #if 0
 677 kprintf ("ReadIconString: \"%s\"\n", str);
 678 #endif
 679
 680     return str;
 681 } /* ReadIconString */
 682
 683 /****************************************************************************************/
 684
 685 static int WriteIconString (struct Hook * streamhook, BPTR file, STRPTR str)
 686 {
 687     ULONG len;
 688
 689     struct IconBase *IconBase = streamhook->h_Data;
 690
 691     len = strlen (str) + 1;
 692
 693     if (!WriteLong (streamhook, len, (APTR)file))
 694         return FALSE;
 695
 696     return FWrite (file, str, len, 1) != EOF;
 697 } /* WriteIconString */
 698
 699 /****************************************************************************************/
 700
 701 AROS_UFH3S(ULONG, ProcessDefaultTool,
 702     AROS_UFHA(struct Hook *,   hook, A0),
 703     AROS_UFHA(struct Hook *,   streamhook, A2),
 704     AROS_UFHA(struct SDData *, data, A1)
 705 )
 706 {
 707     AROS_USERFUNC_INIT
 708
 709     STRPTR str;
 710     struct DiskObject *icon = DO(data->sdd_Dest);
 711
 712 #if 0
 713 kprintf ("ProcessDefaultTool\n");
 714 #endif
 715
 716     if (icon->do_DefaultTool)
 717     {
 718         switch (data->sdd_Mode)
 719         {
 720         case SDV_SPECIALMODE_READ:
 721             str = ReadIconString (icon, streamhook, (BPTR) data->sdd_Stream);
 722
 723             if (!str)
 724                 return FALSE;
 725
 726             icon->do_DefaultTool = str;
 727             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_DEFAULTTOOL_READ;
 728             break;
 729
 730         case SDV_SPECIALMODE_WRITE: {
 731             str = icon->do_DefaultTool;
 732
 733             WriteIconString (streamhook, (BPTR) data->sdd_Stream, str);
 734
 735             break; }
 736
 737         case SDV_SPECIALMODE_FREE:
 738             break;
 739         }
 740     }
 741
 742     return TRUE;
 743
 744     AROS_USERFUNC_EXIT
 745 } /* ProcessDefaultTool */
 746
 747 /****************************************************************************************/
 748
 749 AROS_UFH3S(ULONG, ProcessToolWindow,
 750     AROS_UFHA(struct Hook *,   hook, A0),
 751     AROS_UFHA(struct Hook *,   streamhook, A2),
 752     AROS_UFHA(struct SDData *, data, A1)
 753 )
 754 {
 755     AROS_USERFUNC_INIT
 756
 757     STRPTR str;
 758     struct DiskObject *icon = DO(data->sdd_Dest);
 759
 760 #if 0
 761 kprintf ("ProcessToolWindow\n");
 762 #endif
 763
 764     if (icon->do_ToolWindow)
 765     {
 766         switch (data->sdd_Mode)
 767         {
 768         case SDV_SPECIALMODE_READ:
 769             str = ReadIconString (icon, streamhook, (BPTR)data->sdd_Stream);
 770
 771             if (!str)
 772                 return FALSE;
 773
 774             icon->do_ToolWindow = str;
 775             NATIVEICON(data->sdd_Dest)->ni_ReadStruct_State |= RSS_TOOLWINDOW_READ;
 776             break;
 777
 778         case SDV_SPECIALMODE_WRITE: {
 779             str = icon->do_ToolWindow;
 780
 781             WriteIconString (streamhook, (BPTR)data->sdd_Stream, str);
 782
 783             break; }
 784
 785         case SDV_SPECIALMODE_FREE:
 786             break;
 787         }
 788     }
 789
 790     return TRUE;
 791
 792     AROS_USERFUNC_EXIT
 793 } /* ProcessToolWindow */
 794
 795 /****************************************************************************************/
 796
 797 AROS_UFH3S(ULONG, ProcessToolTypes,
 798     AROS_UFHA(struct Hook *,   hook, A0),
 799     AROS_UFHA(struct Hook *,   streamhook, A2),
 800     AROS_UFHA(struct SDData *, data, A1)
 801 )
 802 {
 803     AROS_USERFUNC_INIT
 804
 805     struct IconBase *IconBase = streamhook->h_Data;
 806     struct DiskObject *icon = DO(data->sdd_Dest);
 807
 808 #if 0
 809 kprintf ("ProcessToolTypes\n");
 810 #endif
 811
 812     if (icon->do_ToolTypes)
 813     {
 814         ULONG    t;
 815         ULONG    count;
 816         STRPTR * ttarray;
 817
 818         switch (data->sdd_Mode)
 819         {
 820         case SDV_SPECIALMODE_READ:
 821             /* Read size of ToolTypes array (each entry is 4 bytes and the
 822                last is 0L */
 823             if (!ReadLong (streamhook, &count, data->sdd_Stream))
 824                 return FALSE;
 825
 826             count = (count >> 2) - 1; /* How many entries */
 827
 828             if ((LONG)count < 0)
 829             {
 830                 icon->do_ToolTypes = NULL;
 831                 return TRUE;
 832             }
 833
 834             ttarray = AllocMemIcon(icon, (count+1)*sizeof(STRPTR), MEMF_PUBLIC);
 835             if (!ttarray) return FALSE;
 836
 837 #if 0
 838 kprintf ("Read %d tooltypes (tt=%p)\n", count, ttarray);
 839 #endif
 840
 841             for (t=0; t<count; t++)
 842             {
 843                 ttarray[t] = ReadIconString (icon, streamhook, (BPTR)data->sdd_Stream);
 844 #if 0
 845 kprintf ("String %d=%p=%s\n", t, ttarray[t], ttarray[t]);
 846 #endif
 847
 848                 if (!ttarray[t])
 849                     return FALSE;
 850             }
 851
 852             ttarray[t] = NULL;
 853
 854             icon->do_ToolTypes = (STRPTR *)ttarray;
 855             NATIVEICON(icon)->ni_ReadStruct_State |= RSS_TOOLTYPES_READ;
 856             break;
 857
 858         case SDV_SPECIALMODE_WRITE: {
 859             ULONG size;
 860
 861             ttarray = (STRPTR *)icon->do_ToolTypes;
 862
 863             for (count=0; ttarray[count]; count++);
 864
 865 #if 0
 866 kprintf ("Write %d tooltypes (%p)\n", count, ttarray);
 867 #endif
 868
 869             size = (count+1)*4;
 870
 871             if (!WriteLong (streamhook, size, data->sdd_Stream))
 872                 return FALSE;
 873
 874             for (t=0; t<count; t++)
 875             {
 876 #if 0
 877 kprintf ("String %d=%p=%s\n", t, ttarray[t], ttarray[t]);
 878 #endif
 879                 if (!WriteIconString (streamhook, (BPTR)data->sdd_Stream, ttarray[t]))
 880                     return FALSE;
 881             }
 882
 883             break; }
 884
 885         case SDV_SPECIALMODE_FREE:
 886             break;
 887         }
 888     }
 889 #if 0
 890     else
 891         kprintf ("No tool types\n");
 892 #endif
 893
 894     return TRUE;
 895
 896     AROS_USERFUNC_EXIT
 897 } /* ProcessToolTypes */
 898
 899 /****************************************************************************************/
 900
 901 AROS_UFH3S(ULONG, ProcessNewDrawerData,
 902     AROS_UFHA(struct Hook *,   hook, A0),
 903     AROS_UFHA(struct Hook *,   streamhook, A2),
 904     AROS_UFHA(struct SDData *, data, A1)
 905 )
 906 {
 907     AROS_USERFUNC_INIT
 908
 909     struct DiskObject *icon = DO(data->sdd_Dest);
 910     IPTR rev = (IPTR)icon->do_Gadget.UserData & WB_DISKREVISIONMASK;
 911 #if 0
 912 kprintf ("ProcessNewDrawerData\n");
 913 #endif
 914
 915     if (icon->do_DrawerData && (rev > 0) && (rev <= WB_DISKREVISION))
 916     {
 917         switch (data->sdd_Mode)
 918         {
 919         case SDV_SPECIALMODE_READ:
 920             if (!ReadLong(streamhook, &icon->do_DrawerData->dd_Flags, data->sdd_Stream))
 921                 return FALSE;
 922
 923             if (!ReadWord(streamhook, &icon->do_DrawerData->dd_ViewModes, data->sdd_Stream))
 924                 return FALSE;
 925
 926             break;
 927
 928         case SDV_SPECIALMODE_WRITE:
 929             if (!WriteLong(streamhook, icon->do_DrawerData->dd_Flags, data->sdd_Stream))
 930                 return FALSE;
 931
 932             if (!WriteWord(streamhook, icon->do_DrawerData->dd_ViewModes, data->sdd_Stream))
 933                 return FALSE;
 934             break;
 935         }
 936     }
 937
 938     return TRUE;
 939
 940     AROS_USERFUNC_EXIT
 941 } /* ProcessNewDrawerData */
 942
 943 /****************************************************************************************/
 944
 945 #define IconBase ((IconBase_T *)(streamhook->h_Data))
 946
 947 /****************************************************************************************/
 948
 949 AROS_UFH3S(ULONG, ProcessIcon35,
 950     AROS_UFHA(struct Hook *,   hook, A0),
 951     AROS_UFHA(struct Hook *,   streamhook, A2),
 952     AROS_UFHA(struct SDData *, data, A1)
 953 )
 954 {
 955     AROS_USERFUNC_INIT
 956
 957     IPTR retval = TRUE;
 958
 959 #if 0
 960 kprintf ("ProcessIcon35\n");
 961 #endif
 962
 963     switch (data->sdd_Mode)
 964     {
 965         case SDV_SPECIALMODE_READ:
 966             ReadIcon35(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
 967             break;
 968
 969         case SDV_SPECIALMODE_FREE:
 970             FreeIcon35(NATIVEICON(DO(data->sdd_Dest)), IconBase);
 971             break;
 972
 973         case SDV_SPECIALMODE_WRITE:
 974             retval = WriteIcon35(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
 975             break;
 976
 977     }
 978
 979     return retval;
 980
 981     AROS_USERFUNC_EXIT
 982 } /* ProcessIcon35 */
 983
 984 /****************************************************************************************/
 985
 986 AROS_UFH3S(ULONG, ProcessIconNI,
 987     AROS_UFHA(struct Hook *,   hook, A0),
 988     AROS_UFHA(struct Hook *,   streamhook, A2),
 989     AROS_UFHA(struct SDData *, data, A1)
 990 )
 991 {
 992     AROS_USERFUNC_INIT
 993
 994     IPTR retval = TRUE;
 995
 996 #if 0
 997 kprintf ("ProcessIconNI\n");
 998 #endif
 999
1000     switch (data->sdd_Mode)
1001     {
1002         case SDV_SPECIALMODE_READ:
1003             ReadIconNI(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
1004             break;
1005
1006         case SDV_SPECIALMODE_FREE:
1007             FreeIconNI(NATIVEICON(DO(data->sdd_Dest)), IconBase);
1008             break;
1009
1010         case SDV_SPECIALMODE_WRITE:
1011             retval = WriteIconNI(NATIVEICON(DO(data->sdd_Dest)), streamhook, data->sdd_Stream, IconBase);
1012             break;
1013
1014     }
1015
1016     return retval;
1017
1018     AROS_USERFUNC_EXIT
1019 } /* ProcessIconNI */
1020
1021 /****************************************************************************************/
1022