workbench/libs/muimaster/classes/dataspace.c

   1 /*
   2     Copyright © 2002-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include <exec/types.h>
  10 #include <clib/alib_protos.h>
  11 #include <proto/exec.h>
  12 #include <proto/intuition.h>
  13 #include <proto/utility.h>
  14 #include <proto/iffparse.h>
  15 #include <proto/muimaster.h>
  16
  17 #include "muimaster_intern.h"
  18 #include "mui.h"
  19 #include "support.h"
  20
  21 extern struct Library *MUIMasterBase;
  22
  23 struct Dataspace_Node
  24 {
  25     struct MinNode node;
  26     ULONG id;
  27     ULONG len;
  28     /* len bytes data follows */
  29 };
  30
  31 struct MUI_DataspaceData
  32 {
  33     /* We store this as a linear list, but it has O(n) when looking
  34     ** for an entry which is bad, because the is the most fequently used
  35     ** operation.
  36     */
  37     struct MinList list;
  38     APTR pool;
  39     APTR pool_allocated;
  40     APTR current_pool;
  41 };
  42
  43 IPTR Dataspace__OM_NEW (struct IClass *cl, Object *obj, struct opSet *msg)
  44 {
  45     struct MUI_DataspaceData *data;
  46     struct TagItem *tags,*tag;
  47
  48     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
  49     if (!obj)
  50         return FALSE;
  51
  52     data = INST_DATA(cl, obj);
  53
  54     for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem**)&tags)); )
  55     {
  56         switch (tag->ti_Tag)
  57         {
  58             case    MUIA_Dataspace_Pool:
  59                     data->pool = (APTR)tag->ti_Data;
  60                     break;
  61         }
  62     }
  63
  64     NewList((struct List*)&data->list);
  65
  66     if (!data->pool)
  67     {
  68         if (!(data->pool_allocated = CreatePool(0,4096,4096)))
  69         {
  70             CoerceMethod(cl,obj,OM_DISPOSE);
  71             return (IPTR)NULL;
  72         }
  73         data->current_pool = data->pool_allocated;
  74     }
  75     else
  76     {
  77         data->current_pool = data->pool;
  78     }
  79
  80     return (IPTR)obj;
  81 }
  82
  83
  84 IPTR Dataspace__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
  85 {
  86     struct MUI_DataspaceData *data = INST_DATA(cl, obj);
  87     if (data->pool_allocated) DeletePool(data->pool_allocated);
  88     else CoerceMethod(cl,obj,MUIM_Dataspace_Clear);
  89     return DoSuperMethodA(cl, obj, msg);
  90 }
  91
  92 IPTR Dataspace__MUIM_Add(struct IClass *cl, Object *obj, struct MUIP_Dataspace_Add *msg)
  93 {
  94     struct MUI_DataspaceData *data = INST_DATA(cl, obj);
  95     struct Dataspace_Node *replace;
  96     struct Dataspace_Node *node;
  97
  98     if (NULL == msg->data || msg->len < 1 || msg->id < 1)
  99         return 0;
 100
 101     node = (struct Dataspace_Node*)AllocVecPooled(data->current_pool,
 102                                                   sizeof(struct Dataspace_Node)+msg->len);
 103     if (NULL == node)
 104     {
 105         return 0;
 106     }
 107
 108     replace = List_First(&data->list);
 109     while (replace)
 110     {
 111         if (replace->id == msg->id)
 112         {
 113             Remove((struct Node*)replace);
 114             FreeVecPooled(data->current_pool, replace);
 115             break;
 116         }
 117         replace = Node_Next(replace);
 118     }
 119
 120     AddTail((struct List*)&data->list,(struct Node*)node);
 121     node->id = msg->id;
 122     node->len = msg->len;
 123     CopyMem(msg->data, node + 1, node->len);
 124     return 1;
 125 }
 126
 127 IPTR Dataspace__MUIM_Clear(struct IClass *cl, Object *obj, struct MUIP_Dataspace_Clear *msg)
 128 {
 129     struct MUI_DataspaceData *data = INST_DATA(cl, obj);
 130     struct Dataspace_Node *node;
 131
 132     node = List_First(&data->list);
 133     while (node)
 134     {
 135         struct Dataspace_Node *tmp = node;
 136         node = Node_Next(node);
 137
 138         FreeVecPooled(data->current_pool, tmp);
 139     }
 140
 141     return 1;
 142 }
 143
 144 IPTR Dataspace__MUIM_Find(struct IClass *cl, Object *obj, struct MUIP_Dataspace_Find *msg)
 145 {
 146     struct MUI_DataspaceData *data = INST_DATA(cl, obj);
 147     struct Dataspace_Node *find;
 148
 149     find = List_First(&data->list);
 150     while (find)
 151     {
 152         if (find->id == msg->id)
 153         {
 154             return (IPTR)(find + 1);
 155         }
 156         find = Node_Next(find);
 157     }
 158
 159     return (IPTR)NULL;
 160 }
 161
 162 IPTR Dataspace__MUIM_Merge(struct IClass *cl, Object *obj, struct MUIP_Dataspace_Merge *msg)
 163 {
 164     return 1;
 165 }
 166
 167 IPTR Dataspace__MUIM_Remove(struct IClass *cl, Object *obj, struct MUIP_Dataspace_Remove *msg)
 168 {
 169     struct MUI_DataspaceData *data = INST_DATA(cl, obj);
 170     struct Dataspace_Node *node;
 171
 172     node = List_First(&data->list);
 173     while (node)
 174     {
 175         if (node->id == msg->id)
 176         {
 177             Remove((struct Node*)node);
 178             FreeVecPooled(data->current_pool, node);
 179             return 1;
 180         }
 181         node = Node_Next(node);
 182     }
 183
 184     return 0;
 185 }
 186
 187 IPTR Dataspace__MUIM_ReadIFF(struct IClass *cl, Object *obj, struct MUIP_Dataspace_ReadIFF *msg)
 188 {
 189     struct ContextNode *cn;
 190     UBYTE *buffer, *p;
 191     LONG read;
 192
 193     LONG len;
 194     ULONG id;
 195
 196     cn = CurrentChunk(msg->handle);
 197     if (!cn)
 198     {
 199         return IFFERR_EOF;
 200     }
 201     if (!(buffer = AllocVec(cn->cn_Size,0)))
 202     {
 203         return IFFERR_NOMEM;
 204     }
 205     read = ReadChunkBytes(msg->handle,buffer,cn->cn_Size);
 206     if (read < 0)
 207     {
 208         FreeVec(buffer);
 209         return read;
 210     }
 211
 212     p = buffer;
 213
 214     while (p < buffer + read)
 215     {
 216         /* Since data can be stored on uneven addresses we must read
 217         ** them byte by byte as MC68000 doesn't like this
 218         */
 219         id = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 220         p+=4;
 221         len = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 222         p+=4;
 223
 224         /* p might be uneven but MUIM_Dataspace_Add use CopyMem() */
 225
 226         /* Now add the data */
 227         DoMethod(obj, MUIM_Dataspace_Add, (IPTR)p, len, id);
 228         p += len;
 229     }
 230     FreeVec(buffer);
 231     return 0;
 232 }
 233
 234 IPTR Dataspace__MUIM_WriteIFF(struct IClass *cl, Object *obj, struct MUIP_Dataspace_WriteIFF *msg)
 235 {
 236     struct MUI_DataspaceData *data = INST_DATA(cl, obj);
 237     struct Dataspace_Node *iter;
 238     LONG rc;
 239
 240     if ((rc = PushChunk(msg->handle,msg->type,msg->id,IFFSIZE_UNKNOWN))) return rc;
 241
 242     iter = List_First(&data->list);
 243     while (iter)
 244     {
 245         ULONG len = iter->len+8;
 246         /* Data is stored in big-endian whatever your machine.
 247          * Be sure sure to convert data to big endian.
 248          */
 249         iter->id = AROS_LONG2BE(iter->id);
 250         iter->len = AROS_LONG2BE(iter->len);
 251         rc = WriteChunkBytes(msg->handle, &iter->id, len); /* ID - LEN - DATA */
 252         iter->id = AROS_LONG2BE(iter->id);
 253         iter->len = AROS_LONG2BE(iter->len);
 254         if (rc < 0)
 255         {
 256             return rc;
 257         }
 258         iter = Node_Next(iter);
 259     }
 260     if ((rc = PopChunk(msg->handle))) return rc;
 261     return 0;
 262 }
 263
 264
 265 BOOPSI_DISPATCHER(IPTR, Dataspace_Dispatcher, cl, obj, msg)
 266 {
 267     IPTR res;
 268
 269     switch (msg->MethodID)
 270     {
 271         /* Whenever an object shall be created using NewObject(), it will be
 272         ** sent a OM_NEW method.
 273         */
 274         case OM_NEW: return Dataspace__OM_NEW(cl, obj, (struct opSet *) msg);
 275         case OM_DISPOSE: return Dataspace__OM_DISPOSE(cl, obj, msg);
 276         case MUIM_Dataspace_Add:
 277             DoMethod(obj, MUIM_Semaphore_Obtain);
 278             res = Dataspace__MUIM_Add(cl, obj, (APTR)msg);
 279             DoMethod(obj, MUIM_Semaphore_Release);
 280             return res;
 281         case MUIM_Dataspace_Clear:
 282             DoMethod(obj, MUIM_Semaphore_Obtain);
 283             res = Dataspace__MUIM_Clear(cl, obj, (APTR)msg);
 284             DoMethod(obj, MUIM_Semaphore_Release);
 285             return res;
 286         case MUIM_Dataspace_Find:
 287             DoMethod(obj, MUIM_Semaphore_ObtainShared);
 288             res = Dataspace__MUIM_Find(cl, obj, (APTR)msg);
 289             DoMethod(obj, MUIM_Semaphore_Release);
 290             /* now that sem is released, imagine that the object gets freed ...
 291              * it really needs that the caller locks the object,
 292              * and release it when done with the result
 293              */
 294             return res;
 295         case MUIM_Dataspace_Merge:
 296             DoMethod(obj, MUIM_Semaphore_Obtain);
 297             res = Dataspace__MUIM_Merge(cl, obj, (APTR)msg);
 298             DoMethod(obj, MUIM_Semaphore_Release);
 299             return res;
 300         case MUIM_Dataspace_Remove:
 301             DoMethod(obj, MUIM_Semaphore_Obtain);
 302             res = Dataspace__MUIM_Remove(cl, obj, (APTR)msg);
 303             DoMethod(obj, MUIM_Semaphore_Release);
 304             return res;
 305         case MUIM_Dataspace_ReadIFF:
 306             DoMethod(obj, MUIM_Semaphore_Obtain);
 307             res = (IPTR)Dataspace__MUIM_ReadIFF(cl, obj, (APTR)msg);
 308             DoMethod(obj, MUIM_Semaphore_Release);
 309             return res;
 310         case MUIM_Dataspace_WriteIFF:
 311             DoMethod(obj, MUIM_Semaphore_Obtain);
 312             res = (IPTR)Dataspace__MUIM_WriteIFF(cl, obj, (APTR)msg);
 313             DoMethod(obj, MUIM_Semaphore_Release);
 314             return res;
 315     }
 316
 317     return DoSuperMethodA(cl, obj, msg);
 318 }
 319 BOOPSI_DISPATCHER_END
 320
 321 /*
 322  * Class descriptor.
 323  */
 324 const struct __MUIBuiltinClass _MUI_Dataspace_desc = {
 325     MUIC_Dataspace,                        /* Class name */
 326     MUIC_Semaphore,                        /* super class name */
 327     sizeof(struct MUI_DataspaceData),      /* size of class own datas */
 328     (void*)Dataspace_Dispatcher            /* class dispatcher */
 329 };