workbench/libs/icon/dupdiskobject.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8 #include <workbench/icon.h>
   9 #include <graphics/gfx.h>
  10 #include <proto/arossupport.h>
  11 #include "icon_intern.h"
  12
  13 /*#define OUTPUT_DATA*/
  14
  15 struct OldDrawerData
  16 {
  17     struct NewWindow dd_NewWindow;
  18     LONG             dd_CurrentX;
  19     LONG             dd_CurrentY;
  20 };
  21
  22
  23 STATIC STRPTR StrDupPooled(APTR pool, STRPTR str)
  24 {
  25     char *newstr;
  26     if (!str) return NULL;
  27     newstr = AllocPooled(pool,strlen(str)+1);
  28     if (newstr) strcpy(newstr,str);
  29     return newstr;
  30 }
  31
  32 STATIC UBYTE *MemDupPooled(APTR pool, UBYTE *src, ULONG size)
  33 {
  34     UBYTE *newmem;
  35
  36     newmem = AllocPooled(pool, size);
  37     if (newmem) memcpy(newmem, src, size);
  38
  39     return newmem;
  40 }
  41
  42 STATIC struct Image *ImageDupPooled(APTR pool, struct Image *src)
  43 {
  44     struct Image *dest;
  45
  46     if (!src) return NULL;
  47
  48     dest = (struct Image*)AllocPooled(pool,sizeof(struct Image));
  49     if (dest)
  50     {
  51         int data_size = 0;
  52         int plane_size;
  53         int i;
  54         int plane_pick = src->PlanePick;
  55
  56         *dest = *src;
  57         dest->NextImage = NULL;
  58
  59         /* Calc the size all used planes */
  60         plane_size = RASSIZE(src->Width,src->Height);
  61         for (i=0;i<8;i++)
  62         {
  63             if (plane_pick & 1) data_size += plane_size;
  64             plane_pick >>= 1;
  65         }
  66
  67         if ((dest->ImageData = AllocPooled(pool,data_size)))
  68         {
  69             memcpy(dest->ImageData,src->ImageData,data_size);
  70 #ifdef OUTPUT_DATA
  71             kprintf("plane_pick = %ld\n",src->PlanePick);
  72             kprintf("width = %ld\n",src->Width);
  73             kprintf("height = %ld\n",src->Height);
  74
  75             for (i=0;i<data_size;i++)
  76             {
  77                 kprintf("0x%02lx,",((unsigned char*)src->ImageData)[i]);
  78                 if (i%16 == 15) kprintf("\n");
  79             }
  80              kprintf("\n");
  81 #endif
  82             return dest;
  83         }
  84
  85         /* Something failed so we fail also */
  86         FreePooled(pool,dest,sizeof(struct Image));
  87     }
  88     return NULL;
  89 }
  90
  91 /*****************************************************************************
  92
  93     NAME */
  94 #include <clib/icon_protos.h>
  95
  96         AROS_LH2(struct DiskObject *, DupDiskObjectA,
  97
  98 /*  SYNOPSIS */
  99         AROS_LHA(struct DiskObject *, icon, A0),
 100         AROS_LHA(struct TagItem *, tags, A1),
 101
 102 /*  LOCATION */
 103         struct Library *, IconBase, 25, Icon)
 104
 105 /*  FUNCTION
 106
 107     INPUTS
 108
 109     RESULT
 110
 111     NOTES
 112
 113     EXAMPLE
 114
 115     BUGS
 116
 117     SEE ALSO
 118
 119     INTERNALS
 120
 121     HISTORY
 122
 123 *****************************************************************************/
 124 {
 125     AROS_LIBFUNC_INIT
 126
 127     APTR pool;
 128     struct NativeIcon *mem;
 129     struct DiskObject *dobj;
 130
 131     if (!icon) return NULL;
 132
 133     pool = CreatePool(0,1024,1024);
 134     if (!pool) return NULL;
 135
 136     /* AROS doesn't need the gfx to be placed in chip memory, so we can use pools */
 137     mem = (struct NativeIcon *)AllocPooled(pool, sizeof(struct NativeIcon));
 138     if (!mem) goto fail;
 139
 140     memset(mem, 0, sizeof(*mem));
 141
 142     mem->pool = pool;
 143     dobj = &mem->dobj;
 144
 145     /* copy the contents */
 146     *dobj = *icon;
 147
 148     if (GetTagData(ICONDUPA_JustLoadedFromDisk, FALSE, tags) != FALSE)
 149     {
 150         struct NativeIcon *srcnativeicon;
 151
 152         srcnativeicon = NATIVEICON(icon);
 153
 154         mem->icon35 = srcnativeicon->icon35;
 155
 156         /* Clone image data */
 157
 158         if (srcnativeicon->icon35.img1.imagedata)
 159         {
 160             mem->icon35.img1.imagedata = MemDupPooled(pool,
 161                                                       srcnativeicon->icon35.img1.imagedata,
 162                                                       srcnativeicon->icon35.width * srcnativeicon->icon35.height);
 163
 164             if (!mem->icon35.img1.imagedata) goto fail;
 165         }
 166
 167         if (srcnativeicon->icon35.img2.imagedata)
 168         {
 169             mem->icon35.img2.imagedata = MemDupPooled(pool,
 170                                                       srcnativeicon->icon35.img2.imagedata,
 171                                                       srcnativeicon->icon35.width * srcnativeicon->icon35.height);
 172
 173             if (!mem->icon35.img2.imagedata) goto fail;
 174         }
 175
 176         /* Clone Image Mask */
 177
 178         if (srcnativeicon->icon35.img1.mask)
 179         {
 180             mem->icon35.img1.mask = MemDupPooled(pool,
 181                                                  srcnativeicon->icon35.img1.mask,
 182                                                  RASSIZE(srcnativeicon->icon35.width, srcnativeicon->icon35.height));
 183         }
 184
 185         if (srcnativeicon->icon35.img2.mask)
 186         {
 187             mem->icon35.img2.mask = MemDupPooled(pool,
 188                                                  srcnativeicon->icon35.img2.mask,
 189                                                  RASSIZE(srcnativeicon->icon35.width, srcnativeicon->icon35.height));
 190         }
 191
 192         /* Clone Palette */
 193
 194         if (srcnativeicon->icon35.img1.palette)
 195         {
 196             mem->icon35.img1.palette = MemDupPooled(pool,
 197                                                     srcnativeicon->icon35.img1.palette,
 198                                                     srcnativeicon->icon35.img1.numcolors * sizeof(struct ColorRegister));
 199             if (!mem->icon35.img1.palette) goto fail;
 200         }
 201
 202         if (srcnativeicon->icon35.img2.palette && (srcnativeicon->icon35.img2.flags & IMAGE35F_HASPALETTE))
 203         {
 204             mem->icon35.img2.palette = MemDupPooled(pool,
 205                                                     srcnativeicon->icon35.img2.palette,
 206                                                     srcnativeicon->icon35.img2.numcolors * sizeof(struct ColorRegister));
 207             if (!mem->icon35.img2.palette) goto fail;
 208         }
 209         else if (srcnativeicon->icon35.img1.palette)
 210         {
 211             /* Both images use same palette which is kept in memory only once */
 212             mem->icon35.img2.palette = mem->icon35.img1.palette;
 213         }
 214
 215         /* Clone PNGIcon data */
 216
 217         mem->iconPNG = srcnativeicon->iconPNG;
 218
 219         if (srcnativeicon->iconPNG.filebuffer)
 220         {
 221             mem->iconPNG.filebuffer = MemDupPooled(pool,
 222                                                    srcnativeicon->iconPNG.filebuffer,
 223                                                    srcnativeicon->iconPNG.filebuffersize);
 224
 225             if (!mem->iconPNG.filebuffer) goto fail;
 226         }
 227
 228         if (srcnativeicon->iconPNG.img1)
 229         {
 230             mem->iconPNG.img1 = MemDupPooled(pool,
 231                                              srcnativeicon->iconPNG.img1,
 232                                              srcnativeicon->iconPNG.width * srcnativeicon->iconPNG.height * sizeof(ULONG));
 233
 234             if (!mem->iconPNG.img1) goto fail;
 235         }
 236
 237         if (srcnativeicon->iconPNG.img2)
 238         {
 239             mem->iconPNG.img2 = MemDupPooled(pool,
 240                                              srcnativeicon->iconPNG.img2,
 241                                              srcnativeicon->iconPNG.width * srcnativeicon->iconPNG.height * sizeof(ULONG));
 242
 243             if (!mem->iconPNG.img2) goto fail;
 244         }
 245
 246     } /* if (GetTagData(ICONDUPA_JustLoadedFromDisk, FALSE, tags) != FALSE) */
 247
 248 #ifdef OUTPUT_DATA
 249     kprintf("gadgetwidth = %ld\ngadgetheight = %ld\n",dobj->do_Gadget.Width,dobj->do_Gadget.Height);
 250 #endif
 251
 252     /* and now the pointers and the rest */
 253 #warning TODO: check for errors here
 254
 255     if (dobj->do_DefaultTool)
 256     {
 257         dobj->do_DefaultTool = StrDupPooled(pool,icon->do_DefaultTool);
 258         if (!dobj->do_DefaultTool) goto fail;
 259     }
 260
 261     if (dobj->do_ToolWindow)
 262     {
 263         dobj->do_ToolWindow = StrDupPooled(pool,icon->do_ToolWindow);
 264         if (!dobj->do_ToolWindow) goto fail;
 265     }
 266
 267     if (icon->do_DrawerData)
 268     {
 269         LONG size;
 270
 271         dobj->do_DrawerData = AllocPooled(pool, sizeof(struct DrawerData));
 272         if (!dobj->do_DrawerData) goto fail;
 273
 274         if (((LONG)icon->do_Gadget.UserData > 0) &&
 275             ((LONG)icon->do_Gadget.UserData <= WB_DISKREVISION))
 276         {
 277             size = sizeof(struct DrawerData);
 278         }
 279         else
 280         {
 281             size = sizeof(struct OldDrawerData);
 282         }
 283
 284         memset(dobj->do_DrawerData, 0, sizeof(struct DrawerData));
 285         memcpy(dobj->do_DrawerData, icon->do_DrawerData, size);
 286     }
 287
 288     /* Duplicate the image data */
 289
 290     if (icon->do_Gadget.GadgetRender)
 291     {
 292         dobj->do_Gadget.GadgetRender = ImageDupPooled(pool, (struct Image*)icon->do_Gadget.GadgetRender);
 293         if (!dobj->do_Gadget.GadgetRender) goto fail;
 294     }
 295
 296     if (icon->do_Gadget.SelectRender)
 297     {
 298         dobj->do_Gadget.SelectRender = ImageDupPooled(pool, (struct Image*)icon->do_Gadget.SelectRender);
 299         if (!dobj->do_Gadget.SelectRender) goto fail;
 300     }
 301
 302     /* Duplicate the tool types */
 303     if (icon->do_ToolTypes)
 304     {
 305         int num_tts;
 306         /* Get number of tool types */
 307         for (num_tts = 0;icon->do_ToolTypes[num_tts];num_tts++);
 308
 309         if ((dobj->do_ToolTypes = (STRPTR *)AllocPooled(pool,sizeof(char*)*(num_tts+1))))
 310         {
 311             int i;
 312             for (i=0;i<num_tts;i++)
 313             {
 314                 dobj->do_ToolTypes[i] = StrDupPooled(pool,icon->do_ToolTypes[i]);
 315                 if (!dobj->do_ToolTypes[i]) goto fail;
 316             }
 317             dobj->do_ToolTypes[i] = NULL;
 318         }
 319         else
 320         {
 321             goto fail;
 322         }
 323     }
 324
 325     AddIconToList(mem, LB(IconBase));
 326
 327     return dobj;
 328
 329 fail:
 330     DeletePool(pool);
 331     return NULL;
 332
 333     AROS_LIBFUNC_EXIT
 334 } /* FreeDiskObject */