workbench/libs/muimaster/classes/bodychunk.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <graphics/gfx.h>
   7 #include <graphics/view.h>
   8 #include <clib/alib_protos.h>
   9 #include <proto/exec.h>
  10 #include <proto/graphics.h>
  11 #include <proto/utility.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14
  15 #include "mui.h"
  16 #include "muimaster_intern.h"
  17 #include "support.h"
  18
  19 extern struct Library *MUIMasterBase;
  20
  21 struct MUI_BodychunkData
  22 {
  23     struct BitMap *bm;
  24     UBYTE *body;
  25     LONG width, height, depth;
  26     UBYTE compression;
  27     UBYTE masking;
  28 };
  29
  30 static void planar2chunky(UBYTE *src, UBYTE *dest, WORD width, WORD depth,
  31     LONG bpr)
  32 {
  33     UBYTE *s, *d, byte;
  34     UBYTE pmask, dmask = 1, notdmask = ~1;
  35     WORD x, pl;
  36
  37     for (pl = 0; pl < depth; pl++)
  38     {
  39         pmask = 0x80;
  40         s = src;
  41         d = dest;
  42
  43         byte = *s++;
  44
  45         for (x = 0; x < width; x++)
  46         {
  47             if (byte & pmask)
  48             {
  49                 *d++ |= dmask;
  50             }
  51             else
  52             {
  53                 *d++ &= notdmask;
  54             }
  55
  56             if (pmask == 0x1)
  57             {
  58                 pmask = 0x80;
  59                 byte = *s++;
  60             }
  61             else
  62             {
  63                 pmask >>= 1;
  64             }
  65         }
  66
  67         dmask <<= 1;
  68         notdmask = ~dmask;
  69
  70         src += bpr;
  71     }
  72 }
  73
  74 static UBYTE *unpack_byterun1(UBYTE *src, UBYTE *dest, LONG unpackedsize)
  75 {
  76     UBYTE r;
  77     BYTE c;
  78
  79     for (;;)
  80     {
  81         c = (BYTE) (*src++);
  82         if (c >= 0)
  83         {
  84             while (c-- >= 0)
  85             {
  86                 *dest++ = *src++;
  87                 if (--unpackedsize <= 0)
  88                     return src;
  89             }
  90         }
  91         else if (c != -128)
  92         {
  93             c = -c;
  94             r = *src++;
  95
  96             while (c-- >= 0)
  97             {
  98                 *dest++ = r;
  99                 if (--unpackedsize <= 0)
 100                     return src;
 101             }
 102         }
 103     }
 104
 105 }
 106
 107 static BOOL make_bitmap(struct IClass *cl, Object *obj)
 108 {
 109     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 110     struct RastPort bmrp, temprp;
 111     UBYTE *chunkyline;
 112     UBYTE *bodyptr, *unpackptr;
 113     LONG w16, bpr, bpl;
 114     WORD x, y, totdepth;
 115
 116     if (!data->body ||
 117         (data->width < 1) ||
 118         (data->height < 1) ||
 119         (data->depth < 1) || (data->depth > 8) || (data->compression > 1))
 120     {
 121         return FALSE;
 122     }
 123
 124     chunkyline = AllocVec(2 * (data->width + 16), MEMF_PUBLIC | MEMF_CLEAR);
 125     if (!chunkyline)
 126         return FALSE;
 127
 128     unpackptr = chunkyline + data->width + 16;
 129
 130     data->bm =
 131         AllocBitMap(data->width, data->height, data->depth, BMF_CLEAR,
 132         NULL);
 133     if (!data->bm)
 134     {
 135         FreeVec(chunkyline);
 136         return FALSE;
 137     }
 138
 139     InitRastPort(&temprp);
 140     temprp.BitMap = AllocBitMap(data->width, 1, 1, 0, NULL);
 141
 142     InitRastPort(&bmrp);
 143     bmrp.BitMap = data->bm;
 144
 145     bodyptr = data->body;
 146     w16 = (data->width + 15) & ~15;
 147     bpr = w16 / 8;
 148
 149     totdepth = data->depth + ((data->masking == 1) ? 1 : 0);
 150     bpl = bpr * totdepth;
 151
 152     for (y = 0; y < data->height; y++)
 153     {
 154         if (data->compression)
 155         {
 156             bodyptr = unpack_byterun1(bodyptr, unpackptr, bpl);
 157             planar2chunky(unpackptr, chunkyline, data->width, data->depth,
 158                 bpr);
 159         }
 160         else
 161         {
 162             planar2chunky(bodyptr, chunkyline, data->width, data->depth,
 163                 bpr);
 164             bodyptr += bpl;
 165         }
 166
 167         if (temprp.BitMap)
 168         {
 169             WritePixelLine8(&bmrp, 0, y, data->width, chunkyline, &temprp);
 170         }
 171         else
 172         {
 173             for (x = 0; x < data->width; x++)
 174             {
 175                 SetAPen(&bmrp, chunkyline[x]);
 176                 WritePixel(&bmrp, x, y);
 177             }
 178         }
 179     }
 180
 181     if (temprp.BitMap)
 182     {
 183         WaitBlit();
 184         FreeBitMap(temprp.BitMap);
 185     }
 186
 187     FreeVec(chunkyline);
 188
 189     return TRUE;
 190 }
 191
 192 /**************************************************************************
 193  OM_NEW
 194 **************************************************************************/
 195 IPTR Bodychunk__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 196 {
 197     struct MUI_BodychunkData *data;
 198     struct TagItem *tag, *tags;
 199
 200     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 201     if (!obj)
 202         return FALSE;
 203
 204     data = INST_DATA(cl, obj);
 205
 206     /* parse initial taglist */
 207
 208     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 209     {
 210         switch (tag->ti_Tag)
 211         {
 212         case MUIA_Bodychunk_Body:
 213             data->body = (UBYTE *) tag->ti_Data;
 214             break;
 215
 216         case MUIA_Bodychunk_Compression:
 217             data->compression = (UBYTE) tag->ti_Data;
 218             break;
 219
 220         case MUIA_Bodychunk_Depth:
 221             data->depth = (LONG) tag->ti_Data;
 222             break;
 223
 224         case MUIA_Bodychunk_Masking:
 225             data->masking = (UBYTE) tag->ti_Data;
 226             break;
 227
 228         case MUIA_Bitmap_Width:
 229             data->width = (LONG) tag->ti_Data;
 230             break;
 231
 232         case MUIA_Bitmap_Height:
 233             data->height = (LONG) tag->ti_Data;
 234             break;
 235
 236         }
 237     }
 238
 239     return (IPTR) obj;
 240 }
 241
 242 /**************************************************************************
 243  OM_DISPOSE
 244 **************************************************************************/
 245 IPTR Bodychunk__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 246 {
 247     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 248
 249     if (data->bm)
 250     {
 251         WaitBlit();
 252         FreeBitMap(data->bm);
 253     }
 254
 255     return DoSuperMethodA(cl, obj, msg);
 256 }
 257
 258 /**************************************************************************
 259  OM_SET
 260 **************************************************************************/
 261 IPTR Bodychunk__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 262 {
 263     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 264     struct TagItem *tags = msg->ops_AttrList;
 265     struct TagItem *tag;
 266
 267     while ((tag = NextTagItem(&tags)) != NULL)
 268     {
 269         switch (tag->ti_Tag)
 270         {
 271         case MUIA_Bodychunk_Body:
 272             data->body = (UBYTE *) tag->ti_Data;
 273             break;
 274
 275         case MUIA_Bodychunk_Compression:
 276             data->compression = (UBYTE) tag->ti_Data;
 277             break;
 278
 279         case MUIA_Bodychunk_Depth:
 280             data->depth = (LONG) tag->ti_Data;
 281             break;
 282
 283         case MUIA_Bodychunk_Masking:
 284             data->masking = (UBYTE) tag->ti_Data;
 285             break;
 286
 287         case MUIA_Bitmap_Width:
 288             data->width = (LONG) tag->ti_Data;
 289             break;
 290
 291         case MUIA_Bitmap_Height:
 292             data->height = (LONG) tag->ti_Data;
 293             break;
 294
 295         }
 296     }
 297
 298     return DoSuperMethodA(cl, obj, (Msg) msg);
 299 }
 300
 301 /**************************************************************************
 302  OM_GET
 303 **************************************************************************/
 304 IPTR Bodychunk__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 305 {
 306 #define STORE *(msg->opg_Storage)
 307
 308     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 309
 310     switch (msg->opg_AttrID)
 311     {
 312     case MUIA_Bodychunk_Body:
 313         STORE = (IPTR) data->body;
 314         return TRUE;
 315
 316     case MUIA_Bodychunk_Compression:
 317         STORE = (IPTR) data->compression;
 318         return TRUE;
 319
 320     case MUIA_Bodychunk_Depth:
 321         STORE = (IPTR) data->depth;
 322         return TRUE;
 323
 324     case MUIA_Bodychunk_Masking:
 325         STORE = (IPTR) data->masking;
 326         return TRUE;
 327
 328     }
 329
 330     return DoSuperMethodA(cl, obj, (Msg) msg);
 331 #undef STORE
 332 }
 333
 334 /**************************************************************************
 335  MUIM_Setup
 336 **************************************************************************/
 337 IPTR Bodychunk__MUIM_Setup(struct IClass *cl, Object *obj,
 338     struct MUIP_Setup *msg)
 339 {
 340     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 341
 342     if (!make_bitmap(cl, obj))
 343         return FALSE;
 344
 345     set(obj, MUIA_Bitmap_Bitmap, (IPTR) data->bm);
 346
 347     if (!DoSuperMethodA(cl, obj, (Msg) msg))
 348     {
 349         set(obj, MUIA_Bitmap_Bitmap, NULL);
 350         WaitBlit();
 351         FreeBitMap(data->bm);
 352         data->bm = NULL;
 353
 354         return FALSE;
 355     }
 356
 357     return TRUE;
 358 }
 359
 360 /**************************************************************************
 361  MUIM_Cleanup
 362 **************************************************************************/
 363 IPTR Bodychunk__MUIM_Cleanup(struct IClass *cl, Object *obj,
 364     struct MUIP_Cleanup *msg)
 365 {
 366     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 367     IPTR retval;
 368
 369     retval = DoSuperMethodA(cl, obj, (Msg) msg);
 370     if (data->bm)
 371     {
 372         set(obj, MUIA_Bitmap_Bitmap, NULL);
 373
 374         WaitBlit();
 375
 376         FreeBitMap(data->bm);
 377         data->bm = NULL;
 378     }
 379
 380     return retval;
 381 }
 382
 383
 384 BOOPSI_DISPATCHER(IPTR, Bodychunk_Dispatcher, cl, obj, msg)
 385 {
 386     switch (msg->MethodID)
 387     {
 388     case OM_NEW:
 389         return Bodychunk__OM_NEW(cl, obj, (struct opSet *)msg);
 390     case OM_DISPOSE:
 391         return Bodychunk__OM_DISPOSE(cl, obj, msg);
 392     case OM_SET:
 393         return Bodychunk__OM_SET(cl, obj, (struct opSet *)msg);
 394     case OM_GET:
 395         return Bodychunk__OM_GET(cl, obj, (struct opGet *)msg);
 396     case MUIM_Setup:
 397         return Bodychunk__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 398     case MUIM_Cleanup:
 399         return Bodychunk__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 400     }
 401
 402     return DoSuperMethodA(cl, obj, msg);
 403 }
 404
 405 BOOPSI_DISPATCHER_END
 406 /*
 407  * Class descriptor.
 408  */
 409 const struct __MUIBuiltinClass _MUI_Bodychunk_desc =
 410 {
 411     MUIC_Bodychunk,
 412     MUIC_Bitmap,
 413     sizeof(struct MUI_BodychunkData),
 414     (void *) Bodychunk_Dispatcher
 415 };